{
 "cells": [
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-08T04:49:27.954050Z",
     "start_time": "2025-06-08T04:49:27.523614Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# ==================== 1. 依赖库导入 ====================\n",
    "import os\n",
    "import re\n",
    "import nltk\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.stem import WordNetLemmatizer\n",
    "from nltk.tokenize import word_tokenize\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.linear_model import Perceptron, LogisticRegression\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV\n",
    "from sklearn.metrics import accuracy_score, classification_report\n"
   ],
   "id": "6cf9fd19af8aa5e9",
   "outputs": [],
   "execution_count": 1
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-08T04:49:30.608597Z",
     "start_time": "2025-06-08T04:49:27.959054Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# ==================== 2. 数据预处理 ====================\n",
    "nltk.download('stopwords')\n",
    "nltk.download('wordnet')\n",
    "nltk.download('punkt')\n",
    "\n",
    "def preprocess_text(text):\n",
    "    # 清洗特殊字符\n",
    "    text = re.sub(r'[^a-zA-Z\\s]', '', text)\n",
    "    # 文本标准化\n",
    "    text = text.lower()\n",
    "    words = word_tokenize(text)\n",
    "    # 停用词过滤\n",
    "    stop_words = set(stopwords.words('english'))\n",
    "    words = [word for word in words if word not in stop_words]\n",
    "    # 词形还原\n",
    "    lemmatizer = WordNetLemmatizer()\n",
    "    words = [lemmatizer.lemmatize(word) for word in words]\n",
    "    # 过滤短词\n",
    "    return \" \".join([word for word in words if len(word) > 2])\n"
   ],
   "id": "fd8644786d5228a3",
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package stopwords to\n",
      "[nltk_data]     C:\\Users\\15038\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package stopwords is already up-to-date!\n",
      "[nltk_data] Downloading package wordnet to\n",
      "[nltk_data]     C:\\Users\\15038\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package wordnet is already up-to-date!\n",
      "[nltk_data] Downloading package punkt to\n",
      "[nltk_data]     C:\\Users\\15038\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package punkt is already up-to-date!\n"
     ]
    }
   ],
   "execution_count": 2
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-08T04:49:30.678482Z",
     "start_time": "2025-06-08T04:49:30.674370Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# ==================== 3. 数据加载 ====================\n",
    "def load_data(data_path):\n",
    "    texts = []\n",
    "    labels = []\n",
    "    for label in ['pos', 'neg']:\n",
    "        for split in ['train', 'test']:\n",
    "            path = os.path.join(data_path, split, label)\n",
    "            for file_name in os.listdir(path):\n",
    "                if file_name.endswith('.txt'):\n",
    "                    with open(os.path.join(path, file_name), 'r', encoding='utf-8') as file:\n",
    "                        texts.append(preprocess_text(file.read()))\n",
    "                        labels.append(1 if label == 'pos' else 0)\n",
    "    return texts, labels"
   ],
   "id": "aba577bd4f520497",
   "outputs": [],
   "execution_count": 3
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-08T04:52:01.986538Z",
     "start_time": "2025-06-08T04:49:30.690766Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# ==================== 4. 数据集划分 ====================\n",
    "data_path = 'D:/mytest/chenyajie/Moive/aclImdb'\n",
    "texts, labels = load_data(data_path)\n",
    "X_train, X_test, y_train, y_test = train_test_split(texts, labels, test_size=0.2, random_state=42)\n"
   ],
   "id": "6954a8edb20f1ead",
   "outputs": [],
   "execution_count": 4
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-08T04:52:15.237211Z",
     "start_time": "2025-06-08T04:52:02.115844Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# ==================== 5. 特征工程 ====================\n",
    "vectorizer = TfidfVectorizer()\n",
    "X_train_vec = vectorizer.fit_transform(X_train)\n",
    "X_test_vec = vectorizer.transform(X_test)"
   ],
   "id": "6b7e2dc9d06a1563",
   "outputs": [],
   "execution_count": 5
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-08T04:52:26.288535Z",
     "start_time": "2025-06-08T04:52:15.259803Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# ==================== 6. 模型训练与评估 ====================\n",
    "# -------------------- 6.1 感知机模型 --------------------\n",
    "import time\n",
    "from sklearn.linear_model import Perceptron\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "# 定义感知机模型的参数网格\n",
    "perceptron_param_grid = {\n",
    "    'alpha': [0.0001, 0.001, 0.01],\n",
    "    'max_iter': [500, 1000, 2000]\n",
    "}\n",
    "\n",
    "# 创建感知机模型\n",
    "perceptron = Perceptron()\n",
    "\n",
    "# 创建网格搜索对象\n",
    "perceptron_grid_search = GridSearchCV(perceptron, perceptron_param_grid, cv=3)\n",
    "\n",
    "# 记录开始时间\n",
    "start_time = time.time()\n",
    "\n",
    "# 模型训练\n",
    "perceptron_grid_search.fit(X_train_vec, y_train)\n",
    "\n",
    "# 记录结束时间\n",
    "end_time = time.time()\n",
    "\n",
    "# 获取最佳模型\n",
    "best_perceptron = perceptron_grid_search.best_estimator_\n",
    "\n",
    "# 预测\n",
    "y_pred_perceptron = best_perceptron.predict(X_test_vec)\n",
    "\n",
    "# 输出分类报告，并格式化小数点四位\n",
    "print(\"Perceptron Classification Report:\")\n",
    "report = classification_report(y_test, y_pred_perceptron, digits=4)\n",
    "print(report)\n",
    "\n",
    "# 计算训练时间\n",
    "training_time = end_time - start_time\n",
    "print(f\"Training Time: {training_time:.4f} seconds\")\n",
    "\n",
    "# 输出最佳参数\n",
    "print(f\"Best Parameters: {perceptron_grid_search.best_params_}\")"
   ],
   "id": "af55aba12b81d90c",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Perceptron Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.8827    0.8604    0.8714      4978\n",
      "           1     0.8650    0.8867    0.8757      5022\n",
      "\n",
      "    accuracy                         0.8736     10000\n",
      "   macro avg     0.8739    0.8735    0.8736     10000\n",
      "weighted avg     0.8738    0.8736    0.8736     10000\n",
      "\n",
      "Training Time: 10.9528 seconds\n",
      "Best Parameters: {'alpha': 0.0001, 'max_iter': 500}\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-08T04:52:47.585948Z",
     "start_time": "2025-06-08T04:52:26.339856Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# -------------------- 6.2 逻辑回归模型 --------------------\n",
    "import time\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "# 定义逻辑回归模型的参数网格\n",
    "logistic_param_grid = {\n",
    "    'C': [0.01, 0.1, 1],\n",
    "    'penalty': ['l1', 'l2'],\n",
    "    'solver': ['liblinear']\n",
    "}\n",
    "\n",
    "# 创建逻辑回归模型\n",
    "logistic = LogisticRegression(max_iter=1000)\n",
    "\n",
    "# 创建网格搜索对象\n",
    "logistic_grid_search = GridSearchCV(logistic, logistic_param_grid, cv=3)\n",
    "\n",
    "# 记录开始时间\n",
    "start_time = time.time()\n",
    "\n",
    "# 模型训练\n",
    "logistic_grid_search.fit(X_train_vec, y_train)\n",
    "\n",
    "# 记录结束时间\n",
    "end_time = time.time()\n",
    "\n",
    "# 获取最佳模型\n",
    "best_logistic = logistic_grid_search.best_estimator_\n",
    "\n",
    "# 预测\n",
    "y_pred_logistic = best_logistic.predict(X_test_vec)\n",
    "\n",
    "# 输出分类报告，并格式化小数点四位\n",
    "print(\"Logistic Regression Classification Report:\")\n",
    "report = classification_report(y_test, y_pred_logistic, digits=4)\n",
    "print(report)\n",
    "\n",
    "# 计算训练时间\n",
    "training_time = end_time - start_time\n",
    "print(f\"Training Time: {training_time:.4f} seconds\")\n",
    "\n",
    "# 输出最佳参数\n",
    "print(f\"Best Parameters: {logistic_grid_search.best_params_}\")"
   ],
   "id": "6a4abe9704b25606",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic Regression Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.9080    0.8903    0.8991      4978\n",
      "           1     0.8933    0.9106    0.9019      5022\n",
      "\n",
      "    accuracy                         0.9005     10000\n",
      "   macro avg     0.9007    0.9005    0.9005     10000\n",
      "weighted avg     0.9006    0.9005    0.9005     10000\n",
      "\n",
      "Training Time: 21.1854 seconds\n",
      "Best Parameters: {'C': 1, 'penalty': 'l2', 'solver': 'liblinear'}\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-08T05:45:54.891334Z",
     "start_time": "2025-06-08T04:52:47.599510Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# -------------------- 6.3 优化后的SVM模型 --------------------\n",
    "import time\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.feature_selection import SelectKBest, chi2\n",
    "\n",
    "# 定义SVM模型的参数网格\n",
    "svm_param_grid = {\n",
    "    'C': [0.1, 1],\n",
    "    'kernel': ['linear'],  # 使用线性核\n",
    "    'gamma': ['scale']\n",
    "}\n",
    "\n",
    "# 创建SVM模型\n",
    "svm = SVC()\n",
    "\n",
    "# 创建网格搜索对象\n",
    "svm_grid_search = GridSearchCV(svm, svm_param_grid, cv=3)\n",
    "\n",
    "# 记录开始时间\n",
    "start_time = time.time()\n",
    "\n",
    "# 特征选择：选择最重要的1000个特征\n",
    "selector = SelectKBest(chi2, k=1000)\n",
    "X_train_vec_reduced = selector.fit_transform(X_train_vec, y_train)\n",
    "X_test_vec_reduced = selector.transform(X_test_vec)\n",
    "\n",
    "# 模型训练\n",
    "svm_grid_search.fit(X_train_vec_reduced, y_train)\n",
    "\n",
    "# 记录结束时间\n",
    "end_time = time.time()\n",
    "\n",
    "# 获取最佳模型\n",
    "best_svm = svm_grid_search.best_estimator_\n",
    "\n",
    "# 预测\n",
    "y_pred_svm = best_svm.predict(X_test_vec_reduced)\n",
    "\n",
    "# 输出分类报告，并格式化小数点四位\n",
    "print(\"SVM Classification Report:\")\n",
    "report = classification_report(y_test, y_pred_svm, digits=4)\n",
    "print(report)\n",
    "\n",
    "# 计算训练时间\n",
    "training_time = end_time - start_time\n",
    "print(f\"Training Time: {training_time:.4f} seconds\")\n",
    "\n",
    "# 输出最佳参数\n",
    "print(f\"Best Parameters: {svm_grid_search.best_params_}\")"
   ],
   "id": "a521de71543f0881",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.8943    0.8648    0.8793      4978\n",
      "           1     0.8702    0.8986    0.8842      5022\n",
      "\n",
      "    accuracy                         0.8818     10000\n",
      "   macro avg     0.8822    0.8817    0.8817     10000\n",
      "weighted avg     0.8822    0.8818    0.8818     10000\n",
      "\n",
      "Training Time: 3086.6017 seconds\n",
      "Best Parameters: {'C': 1, 'gamma': 'scale', 'kernel': 'linear'}\n"
     ]
    }
   ],
   "execution_count": 8
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-08T05:45:57.626258Z",
     "start_time": "2025-06-08T05:45:55.011193Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# -------------------- 6.4 朴素贝叶斯模型 --------------------\n",
    "import time\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "# 定义朴素贝叶斯模型的参数网格\n",
    "nb_param_grid = {\n",
    "    'alpha': [0.01, 0.1, 1],\n",
    "    'fit_prior': [True, False]\n",
    "}\n",
    "\n",
    "# 创建朴素贝叶斯模型\n",
    "nb = MultinomialNB()\n",
    "\n",
    "# 创建网格搜索对象\n",
    "nb_grid_search = GridSearchCV(nb, nb_param_grid, cv=3)\n",
    "\n",
    "# 记录开始时间\n",
    "start_time = time.time()\n",
    "\n",
    "# 模型训练\n",
    "nb_grid_search.fit(X_train_vec, y_train)\n",
    "\n",
    "# 记录结束时间\n",
    "end_time = time.time()\n",
    "\n",
    "# 获取最佳模型\n",
    "best_nb = nb_grid_search.best_estimator_\n",
    "\n",
    "# 预测\n",
    "y_pred_nb = best_nb.predict(X_test_vec)\n",
    "\n",
    "# 输出分类报告，并格式化小数点四位\n",
    "print(\"Naive Bayes Classification Report:\")\n",
    "report = classification_report(y_test, y_pred_nb, digits=4)\n",
    "print(report)\n",
    "\n",
    "# 计算训练时间\n",
    "training_time = end_time - start_time\n",
    "print(f\"Training Time: {training_time:.4f} seconds\")\n",
    "\n",
    "# 输出最佳参数\n",
    "print(f\"Best Parameters: {nb_grid_search.best_params_}\")"
   ],
   "id": "59a7cd2fc7993138",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Naive Bayes Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.8561    0.8867    0.8711      4978\n",
      "           1     0.8836    0.8523    0.8676      5022\n",
      "\n",
      "    accuracy                         0.8694     10000\n",
      "   macro avg     0.8698    0.8695    0.8694     10000\n",
      "weighted avg     0.8699    0.8694    0.8694     10000\n",
      "\n",
      "Training Time: 2.4938 seconds\n",
      "Best Parameters: {'alpha': 1, 'fit_prior': False}\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-08T05:49:35.870548Z",
     "start_time": "2025-06-08T05:45:57.652928Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# ==================== 6.5 决策树模型优化 ====================\n",
    "import time\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.model_selection import RandomizedSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "# 定义决策树模型的参数网格\n",
    "dt_param_grid = {\n",
    "    'criterion': ['gini', 'entropy'],\n",
    "    'max_depth': [None, 10, 30],\n",
    "    'min_samples_split': [2, 10],\n",
    "    'min_samples_leaf': [1, 4]\n",
    "}\n",
    "\n",
    "# 创建决策树模型\n",
    "dt = DecisionTreeClassifier(random_state=42)\n",
    "\n",
    "# 创建随机搜索对象，设置 n_iter=10，cv=2，并行化计算\n",
    "dt_random_search = RandomizedSearchCV(dt, dt_param_grid, n_iter=10, cv=2, n_jobs=-1, random_state=42)\n",
    "\n",
    "# 记录开始时间\n",
    "start_time = time.time()\n",
    "\n",
    "# 模型训练\n",
    "dt_random_search.fit(X_train_vec, y_train)\n",
    "\n",
    "# 记录结束时间\n",
    "end_time = time.time()\n",
    "\n",
    "# 获取最佳模型\n",
    "best_dt = dt_random_search.best_estimator_\n",
    "\n",
    "# 预测\n",
    "y_pred_dt = best_dt.predict(X_test_vec)\n",
    "\n",
    "# 输出分类报告，并格式化小数点四位\n",
    "print(\"Decision Tree Classification Report:\")\n",
    "report = classification_report(y_test, y_pred_dt, digits=4)\n",
    "print(report)\n",
    "\n",
    "# 计算训练时间\n",
    "training_time = end_time - start_time\n",
    "print(f\"Training Time: {training_time:.4f} seconds\")\n",
    "\n",
    "# 输出最佳参数\n",
    "print(f\"Best Parameters: {dt_random_search.best_params_}\")"
   ],
   "id": "63d572bb97ae5426",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decision Tree Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.7632    0.6902    0.7249      4978\n",
      "           1     0.7195    0.7877    0.7521      5022\n",
      "\n",
      "    accuracy                         0.7392     10000\n",
      "   macro avg     0.7414    0.7390    0.7385     10000\n",
      "weighted avg     0.7413    0.7392    0.7386     10000\n",
      "\n",
      "Training Time: 218.0391 seconds\n",
      "Best Parameters: {'min_samples_split': 10, 'min_samples_leaf': 4, 'max_depth': 30, 'criterion': 'gini'}\n"
     ]
    }
   ],
   "execution_count": 10
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-08T06:06:14.732308Z",
     "start_time": "2025-06-08T05:49:35.937689Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# -------------------- 6.6 K近邻模型 --------------------\n",
    "import time\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "# 定义K近邻模型的参数网格\n",
    "knn_param_grid = {\n",
    "    'n_neighbors': [3, 5, 7, 9],\n",
    "    'weights': ['uniform', 'distance'],\n",
    "    'algorithm': ['brute']  # 显式指定使用brute算法\n",
    "}\n",
    "\n",
    "# 创建K近邻模型\n",
    "knn = KNeighborsClassifier()\n",
    "\n",
    "# 创建网格搜索对象\n",
    "knn_grid_search = GridSearchCV(knn, knn_param_grid, cv=3)\n",
    "\n",
    "# 记录开始时间\n",
    "start_time = time.time()\n",
    "\n",
    "# 模型训练\n",
    "knn_grid_search.fit(X_train_vec, y_train)\n",
    "\n",
    "# 记录结束时间\n",
    "end_time = time.time()\n",
    "\n",
    "# 获取最佳模型\n",
    "best_knn = knn_grid_search.best_estimator_\n",
    "\n",
    "# 预测\n",
    "y_pred_knn = best_knn.predict(X_test_vec)\n",
    "\n",
    "# 输出分类报告，并格式化小数点四位\n",
    "print(\"K-Nearest Neighbors Classification Report:\")\n",
    "report = classification_report(y_test, y_pred_knn, digits=4)\n",
    "print(report)\n",
    "\n",
    "# 计算训练时间\n",
    "training_time = end_time - start_time\n",
    "print(f\"Training Time: {training_time:.4f} seconds\")\n",
    "\n",
    "# 输出最佳参数\n",
    "print(f\"Best Parameters: {knn_grid_search.best_params_}\")"
   ],
   "id": "3b4614cb50aa39e2",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "K-Nearest Neighbors Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0     0.8289    0.7121    0.7661      4978\n",
      "           1     0.7496    0.8542    0.7985      5022\n",
      "\n",
      "    accuracy                         0.7835     10000\n",
      "   macro avg     0.7892    0.7832    0.7823     10000\n",
      "weighted avg     0.7891    0.7835    0.7824     10000\n",
      "\n",
      "Training Time: 979.7916 seconds\n",
      "Best Parameters: {'algorithm': 'brute', 'n_neighbors': 9, 'weights': 'distance'}\n"
     ]
    }
   ],
   "execution_count": 11
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-08T06:06:14.791412Z",
     "start_time": "2025-06-08T06:06:14.768211Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "# ==================== 7. 可视化 ====================\n",
    "# 获取各模型的准确率和训练时间\n",
    "models = ['Perceptron', 'Logistic Regression', 'SVM', 'Naive Bayes', 'Decision Tree', 'K-Nearest Neighbors']\n",
    "accuracies = [\n",
    "    accuracy_score(y_test, y_pred_perceptron),\n",
    "    accuracy_score(y_test, y_pred_logistic),\n",
    "    accuracy_score(y_test, y_pred_svm),\n",
    "    accuracy_score(y_test, y_pred_nb),\n",
    "    accuracy_score(y_test, y_pred_dt),\n",
    "    accuracy_score(y_test, y_pred_knn)\n",
    "]\n",
    "training_times = [\n",
    "    perceptron_grid_search.refit_time_,\n",
    "    logistic_grid_search.refit_time_,\n",
    "    svm_grid_search.refit_time_,\n",
    "    nb_grid_search.refit_time_,\n",
    "    dt_random_search.refit_time_,\n",
    "    knn_grid_search.refit_time_\n",
    "]"
   ],
   "id": "205fdf01524ea8ec",
   "outputs": [],
   "execution_count": 12
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-08T06:06:15.368403Z",
     "start_time": "2025-06-08T06:06:14.798429Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 绘制准确率柱状图\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.bar(models, accuracies, color='skyblue')\n",
    "plt.xlabel('Model')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.title('Model Accuracy Comparison')\n",
    "plt.ylim(0, 1)  # 限制y轴范围在0到1之间\n",
    "for i, v in enumerate(accuracies):\n",
    "    plt.text(i, v + 0.01, str(round(v, 4)), ha='center')  # 在柱子上方显示准确率值\n",
    "plt.show()"
   ],
   "id": "37a441c1949292dd",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 13
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-08T06:06:15.515446Z",
     "start_time": "2025-06-08T06:06:15.387258Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 绘制训练时间柱状图\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.bar(models, training_times, color='lightgreen')\n",
    "plt.xlabel('Model')\n",
    "plt.ylabel('Training Time (seconds)')\n",
    "plt.title('Model Training Time Comparison')\n",
    "for i, v in enumerate(training_times):\n",
    "    plt.text(i, v + 0.01, str(round(v, 4)), ha='center')  # 在柱子上方显示训练时间值\n",
    "plt.show()"
   ],
   "id": "2449ee442c8eb0b3",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 14
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-08T06:06:15.706307Z",
     "start_time": "2025-06-08T06:06:15.533820Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 绘制SVM混淆矩阵\n",
    "svm_conf_matrix = confusion_matrix(y_test, y_pred_svm)\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(svm_conf_matrix, annot=True, fmt='d', cmap='Blues',\n",
    "            xticklabels=['Negative', 'Positive'], yticklabels=['Negative', 'Positive'])\n",
    "plt.xlabel('Predicted Label')\n",
    "plt.ylabel('True Label')\n",
    "plt.title('SVM Confusion Matrix')\n",
    "plt.show()"
   ],
   "id": "fd3b35178ffe5152",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 15
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-08T06:06:15.913605Z",
     "start_time": "2025-06-08T06:06:15.721107Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 提取各模型的召回率\n",
    "recalls = [\n",
    "    classification_report(y_test, y_pred_perceptron, output_dict=True)['1']['recall'],\n",
    "    classification_report(y_test, y_pred_logistic, output_dict=True)['1']['recall'],\n",
    "    classification_report(y_test, y_pred_svm, output_dict=True)['1']['recall'],\n",
    "    classification_report(y_test, y_pred_nb, output_dict=True)['1']['recall'],\n",
    "    classification_report(y_test, y_pred_dt, output_dict=True)['1']['recall'],\n",
    "    classification_report(y_test, y_pred_knn, output_dict=True)['1']['recall']\n",
    "]\n",
    "\n",
    "# 绘制召回率柱状图\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.bar(models, recalls, color='lightcoral')\n",
    "plt.xlabel('Model')\n",
    "plt.ylabel('Recall')\n",
    "plt.title('Model Recall Comparison')\n",
    "plt.ylim(0, 1)  # 限制y轴范围在0到1之间\n",
    "for i, v in enumerate(recalls):\n",
    "    plt.text(i, v + 0.01, str(round(v, 4)), ha='center')  # 在柱子上方显示召回率值\n",
    "plt.show()"
   ],
   "id": "720c1d8c2221bf4",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ],
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0kAAAIeCAYAAABuhUS7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABnlUlEQVR4nO3dd3xO5+P/8XcmiU1UrFIrtkQSKUqIWrEJ2qpWB9U0SKwYtWdblCBGUZTSmqVWB8WnVUr51qpVI6RWzIjs8/vDI/fv3A0aJUO8no9HHo/c17nOOdc51z3O+z7nXLeNYRiGAAAAAACSJNvMbgAAAAAAZCWEJAAAAAAwISQBAAAAgAkhCQAAAABMCEkAAAAAYEJIAgAAAAATQhIAAAAAmBCSAAAAAMCEkAQAAAAAJoQkAMhgXbt2lZubm1555ZUH1gkJCZGbm5sGDRr02OvbvXu33NzctHv37jTPc/78ebm5uWn16tUPrDNo0CC5ublZ/VWsWFEeHh5q06aNFi9e/Nht/6/c3Nw0ffp0SY+2/QcPHtSAAQPUoEEDVa9eXY0aNdKHH36oiIiI9G5yhlm9erXc3Nx0/vz5zG4KAGRZ9pndAAB4Ftna2urAgQP6+++/VbRoUatpd+/e1U8//ZQ5DXtEhQsX1owZMyyPDcPQ1atXtXz5co0bN06Ojo4PDYNZydKlSzV+/Hj5+PioX79+eu6553Tu3DnNmzdP3333nT7//HNVqVIls5v52Bo0aKCvvvpKzz33XGY3BQCyLEISAGSCypUr6+TJk9q8ebPeeustq2lbt25Vjhw5lCdPnkxqXdo5OjrK3d09VXmDBg3UuHFjrVy58qkISfv27dO4cePUpUsXDR061FLu4+OjRo0aqX379ho8eLDWrVuXia18MgoWLKiCBQtmdjMAIEvjcjsAyATOzs7y9fXVpk2bUk3buHGjmjVrJnt76++x4uLiNHPmTDVr1kzVqlVTkyZNNHfuXCUnJ1vVW758uZo2barq1avr9ddfV2RkZKp1REZGqm/fvqpVq5Zq1KihN998U0eOHHli2+fg4KCcOXOmKv/hhx/Uvn17VatWTXXr1tXYsWMVExNjVefQoUN699135enpqRdffFEhISH6+++/LdP//PNPBQUF6cUXX1SVKlVUr149jR07VrGxsf+5vfPnz1eePHnUt2/fVNMKFiyoQYMGqUmTJoqOjraUb9y4Ue3bt5eHh4fq1q2r4cOH6+bNm5bp06dPV7NmzfTDDz+oZcuWqlatmtq0aaP9+/frwIED6tixo6pXr66WLVtq165dVvP5+flp27ZtatasmWrUqKGOHTta1UnrfnBzc9OMGTPUoUMHeXp6Kjw8PNXldteuXVP//v1Vt25dSxvXrl1rta4zZ86od+/eqlu3rtzd3dW1a1ft27fPMj3l8sxNmzapd+/e8vDwkLe3t4YOHao7d+78t04BgExESAKATOLv76//+7//swox0dHR2rFjh1q2bGlV1zAM9ezZU/PmzVNAQIBmz56tZs2aaerUqRoxYoSl3pIlSzRixAjVq1dP4eHhqlGjhoYNG2a1rGvXrumVV17R4cOHNWzYME2ePFnJycnq0qWLTp069cjbkZiYaPmLj49XZGSkPv74Y50+fVpt27a11Fu/fr0++OADlSlTRjNnzlRQUJDWrVunwMBAGYYh6d6B/6uvvqq7d+9q4sSJGj16tI4cOaK3335bCQkJunz5srp06WKZ/tlnn6l58+b64osvtHDhwkdue8q+/d///qfatWvLycnpvnWaNWumoKAg5c6dW5IUHh6ukJAQ1ahRQ2FhYfrggw+0ZcsWde3a1SqkXLx4URMmTFDPnj01depU3bx5U71791bfvn3VqVMnTZkyRcnJyQoJCbGa79q1awoNDdVrr72madOmycnJSd27d9ehQ4ck6ZH2w6xZs9S0aVNNmTJFjRo1SrVtAwYM0MmTJzVq1CjNnTtXlStXVmhoqOUerpMnT6p9+/aKiIjQhx9+qEmTJsnGxkZvvvmm9uzZY7WsESNGqHjx4goPD9e7776rVatWafbs2Y/eKQCQybjcDgAySYMGDeTs7KzNmzfr7bffliR9//33KliwoDw9Pa3q7tixQ7/88os++eQTtW7dWpJUt25d5cyZU9OmTdObb76psmXLKjw8XE2bNtWHH34oSXrppZcUHR2t5cuXW5a1aNEi3bhxQ8uWLVPx4sUlSfXr15e/v7+mTZumsLCwNG/DhQsX7nufTunSpTVixAi9+uqrku4FkUmTJqlevXqaNGmSVb1u3bpp+/btatCggcLDw5UvXz4tWLBAOXLkkCS5uroqODhYx44d040bN1SpUiVNmzbNEljq1KmjXbt26bffflPPnj3T3PYU169fV1xcnEqUKJGm+jdv3tSsWbPUsWNHq4BaoUIFdenSRatXr9Zrr70m6d79ZSNGjFD9+vUlSadOndLkyZM1btw4BQQESJKSkpLUu3dvnT59WpUqVbLMN3LkSEvIfPHFF/Xyyy9r7ty5CgsL0/Hjx9O8H6pXr64ePXpYHh8+fNhqe/bs2aPAwEC9/PLLku5dYpg/f37Z2dlJkmbMmCEHBwctXrzYcglogwYN1LJlS33yySdasWKFZVm+vr4KDQ2VJNWuXVs///yzfvrpJ/Xr1y9N+xYAsgpCEgBkkpw5c8rPz0+bNm2yhKQNGzbI399fNjY2VnX37NkjOzs7+fv7W5W3bt1a06ZN0+7du2VjY6OoqKhUZwuaN29uFZJ27dqlSpUqqUiRIkpMTJR0byCJ+vXrP/I9N4ULF9asWbMk3Qsbc+bM0blz5zR+/HiroPfXX3/p4sWLeu+99yzrlCRvb2/lzp1bP//8sxo0aKB9+/bJ19fXEpCkewf5W7dutTx+6aWXlJCQoNOnT+vMmTM6duyYrl27pvz58z9S21PY2t67qCIpKSlN9Q8cOKD4+Hi1atXKqtzLy0vFixfX7t27LSFJkmrWrGn538XFRZKs7uNKafetW7csZXZ2dmrRooXlcc6cOVW/fn1t375d0r19kNb9UKFChYduj4+Pj6ZPn64///xTvr6+ql+/viXoSPeeew0bNrS6R87e3l4tWrTQzJkzrS6n++f9aa6urrpw4cJD1w8AWREhCQAyUfPmzfXBBx/o/PnzypUrl3bt2qXg4OBU9W7evKkCBQqkuk+pcOHCkqTbt29b7of55035KXVS3LhxQ2fPnn3gSG13795Nc/sdHR1VrVo1y2Nvb2916tRJPXr00IoVK1SmTBnLOiVp1KhRGjVqVKrlXL582VKvUKFCD1xfcnKypkyZoqVLlyomJkZFixZV9erVrULVo8qfP79y5cp133u3UsTExCg+Pl758+e37OeUwGPm4uKi27dvW5WlnOkxu9/9WmYFCxaUg4ODVVmhQoUs636U/XC/dpp9+umnmj17tjZt2qTNmzfL1tZWderU0ciRI1WyZEndvHnzgdtqGIbVfVr/vFzR1tbWciklADxNCEkAkInq16+vPHnyaMuWLcqTJ49KlCihqlWrpqqXL18+Xb9+XYmJiVZBKSVcFChQQAUKFJAkRUVFWc2bElBS5MmTR7Vq1dLAgQPv2yZHR8f/vD1OTk4aP368OnXqpCFDhmjZsmWysbFR3rx5JUkDBw5UrVq17rt9KW27du1aqunbt29XxYoVtWbNGi1cuFAjR45U06ZNLWc3Ui5d+69eeukl7d69W3FxcfcNGqtXr9a4ceP05ZdfWtp69epVlS1b1qrelStXVLJkycdqi3SvzwzDsDqjePXqVUuAnDt37hPbD3ny5NGAAQM0YMAA/fXXX/rxxx8VHh6uUaNGad68ecqXL5+uXr2aar4rV65IuvfcS3keAkB2wcANAJCJHB0d1ahRI3333XfatGmT1SVWZrVq1VJSUpI2btxoVZ5yeZynp6dKly6tokWLavPmzVZ1tm3blmpZp0+f1gsvvKBq1apZ/tatW6cVK1ZY7kX5r6pVq6ZOnTpp//79WrNmjSSpTJkyKlSokM6fP2+1TldXV02ePNkysp6Xl5d27typ+Ph4y/KOHTumHj166ODBg9q3b5/KlSungIAASzC4dOmSjh8/nmqUv0fx9ttv68aNG/r0009TTYuKitK8efNUqlQpubu7q0aNGnJ0dNT69eut6u3du1eRkZFWl9f9VwkJCdq5c6flcWxsrHbs2KHatWtL0hPbDxcuXJCvr6/lOVOmTBl1795dderU0cWLFyXdOzu4bds2qzNkSUlJ2rBhg6pVq/ZYoRoAsirOJAFAJvP399d7770nW1tby4AL/1S/fn35+PhoxIgRunz5sipXrqw9e/bos88+U7t27VSuXDlJUv/+/dWvXz99+OGHatasmQ4cOKBly5ZZLatbt2765ptv1K1bN7399tsqUKCANm7cqK+//lqDBw9+ItsUHBysTZs2afLkyWrcuLHy5MmjkJAQDR8+XHZ2dmrYsKFu3bql8PBwXbp0yXLpX2BgoDp37qzu3bvrzTffVHx8vKZNm6YqVaqofv36Onr0qMLDwzV37ly5u7vr7NmzmjNnjuLj4x/pMsF/cnd3V58+fTR16lSdOnVK7dq1U4ECBXTixAktWLBAd+7c0dy5c2VjY6P8+fOrR48elgENGjVqpPPnz2vatGkqV66c2rdv/0T24ZAhQxQcHKxChQpp/vz5iomJ0fvvvy/p3n1aT2I/FC9eXK6urho7dqyio6P1/PPP69ChQ9q+fbvee+89SVJQUJB27NihN954Qz169JCjo6OWLFmiiIgIzZs374lsKwBkNYQkAMhkderUUd68eVW0aNFUl2+lsLGx0Zw5cxQWFqbFixfr2rVrKlGihEJCQqx+jLZly5aytbVVeHi4vvnmG1WoUEGjR4+2+v2fIkWKaPny5Zo8ebJGjhypuLg4lS5d2mrEtcdVoEAB9enTR6NHj1ZYWJiGDh2qjh07KleuXJo3b56++uorOTs7q2bNmpo0aZLlErXKlSvriy++0OTJkxUSEqJcuXLJ19dX/fv3l6Ojo9577z1dv35dixcv1syZM1W0aFG1adPGsn9u3rxpuRzuUb3//vuqXLmyli5dqgkTJujGjRtydXVV/fr11bNnTxUrVsxSt1evXnJxcdGSJUu0YsUK5c+fX82aNVNwcPADhxF/VCNHjtT48eN17do11axZU8uWLVOpUqUk6YnuhxkzZmjKlCmaNm2arl+/rqJFiyooKMgyIl758uX15ZdfasqUKRoyZIhsbGxUvXp1LV68WF5eXk9kWwEgq7ExuKMSAIAsY/r06ZoxY4aOHTuW2U0BgGcW9yQBAAAAgAkhCQAAAABMuNwOAAAAAEwy9UzStWvX1LhxY+3evfuBdbZv365WrVrJ3d1dzZs3TzWULQAAAAA8SZkWkvbt26fOnTvr3LlzD6xz5swZ9erVS3369NHevXvVq1cvBQcH69KlSxnYUgAAAADPkkwJSWvWrFH//v0VEhLyr/W8vLz08ssvy97eXv7+/vL29tZXX32VQS0FAAAA8KzJlN9Jeumll9SqVSvZ29s/NCidPHlSFSpUsCorV66c/vzzzzSvKzk5WYmJibK1tZWNjc1/bjMAAACAp5thGEpOTpa9vb1sbR98vihTQlLhwoXTVO/OnTupfpQvZ86ciomJSfO6EhMTdfDgwUdqHwAAAIDsq1q1anJ0dHzg9EwJSWnl5OSk2NhYq7LY2FjlypUrzctISYiVK1eWnZ3dE23fsyYpKUlHjhxhX2Zz9HP2Rx8/G+jn7I8+fjbQz09Wyv582FkkKYuHpAoVKujw4cNWZSdPnlTVqlXTvIyUS+wcHR15Yj2mpKQkSezL7I5+zv7o42cD/Zz90cfPBvr5yUrZn/92G06W/jHZ1q1ba8+ePdq4caMSExO1ceNG7dmzR23atMnspgEAAADIprJcSPLw8NC6deskSWXLltXMmTM1Z84ceXt7Kzw8XNOnT9cLL7yQya0EAAAAkF1l+uV2x44ds3q8f/9+q8f16tVTvXr1MrJJAAAAAJ5hWe5MEgAAAABkJkISAAAAAJgQkgAAAADAhJAEAAAAACaEJAAAAAAwISQBAAAAgAkhCQAAAABMCEkAAAAAYEJIAgAAAAATQhIAAAAAmBCSAAAAAMCEkAQAAAAAJoQkAAAAADAhJAEAAACACSEJAAAAAEwISQAAAABgQkgCAAAAABNCEgAAAACYEJIAAAAAwISQBAAAAAAmhCQAAAAAMCEkAQAAAIAJIQnIBqKiohQYGCgvLy/5+Pho3LhxSkxMvG/d1atXq1mzZvLw8FDnzp3122+/3bfe+PHjNWjQIKuymJgYDR48WD4+PvL09NTAgQN1584dy/QLFy5YtSM0NNRqOgAAwNOAkARkA8HBwXJ2dtbOnTu1cuVK7dq1SwsXLkxV78cff9SIESMUGhqqvXv36p133lH37t31119/WercuHFDM2fO1JIlS1LNP2bMGP3999/asmWLvvvuO/3999+aNGmSJCk+Pl5vv/22XF1dtXPnTm3atElnz57V5MmT0227AQAA0gMhCXjKnT17Vnv27NGAAQPk5OSkkiVLKjAwUEuXLk1V99tvv1XLli3VsGFD2dnZqUmTJvLy8tKqVaskSXfu3JG/v7+cnZ3VpEkTq3nv3r2r9evXq3fv3sqfP78KFSqk/v37a/Xq1bp79662bdum+Ph4DR06VE5OTipYsKDCwsL0xhtvZMh+AAAAeFIIScBT7sSJE8qfP7+KFCliKStbtqwiIyN169Ytq7pJSUlydna2KrO1tbWcScqRI4fWrVunt956K1W9s2fPKiEhQRUqVLBaT2xsrM6cOaM//vhDFStW1LRp09SgQQM1aNBA8+fPl6ur65PeZAAAgHRFSAKecnfu3JGTk5NVWcrjmJgYq/KmTZtq7dq12rNnjxITE/XDDz9o165diouLkyTZ29vLxcXlvuuJjo6WJKvwlLKeO3fu6ObNm9qxY4dy5MihLVu26IsvvtDu3bv18ccfP5kNBQAAyCCEJOAp5+zsrLt371qVpTzOlSuXVXmLFi0UHBysYcOG6aWXXtL333+vli1bKm/evGlaj3nZ5v9z584tR0dHubi46IMPPlCOHDlUsmRJvffee9q0adNjbR8AAEBGIyQBT7ny5cvrxo0bunr1qqXs1KlTcnV1VZ48eazqXrlyRfXq1dOWLVv066+/6qOPPtKpU6dUtWrVf13PCy+8IAcHB508edJqPQ4ODipdurTKli2rhIQEJScnW6YnJyfLMIwnsJWQHm0Uw0WLFsnPz081a9ZUq1attGXLFsu0+Ph4LVu2TA0bNpS3t7c++OAD/f3335bpERER6t69u2rVqqXatWtr4MCBVpduMoohACC7IyQBT7nSpUvL09NT48ePV3R0tCIiIhQeHq6AgIBUdX/77Td17dpVFy5cUFxcnBYuXKjTp0+rXbt2/7oeJycnNW/eXJMmTdK1a9d07do1TZo0SS1btlTOnDnVvHlzJSUlafz48YqPj9f58+c1e/ZstWnTJj02+5mU1lEMt2/frjlz5mjevHn6/fffFRQUpODgYJ0/f16S9Omnn2rPnj2aO3eufv75Z5UqVUpvvfWW4uPjJUl9+/ZVuXLl9PPPP2vTpk2KjIzUxIkTJTGKIQDg2UBIArKBsLAwJSYmqlGjRurUqZPq1aunwMBASZKHh4fWrVsnSfL391fnzp3VuXNn1a5dWz/++KMWLVqkQoUKpWk9I0aMUOnSpdWqVSs1a9ZMJUqU0PDhwyVJBQsW1LJly3T27FnVr19fAQEBql27tvr165c+G/2MeZRRDP/66y8ZhmH5s7Ozk4ODg+zt7SXdG+WwXbt2Kl++vBwdHdWvXz9dunRJu3btknTvDKF5fhsbG8v9Z4xiCAB4FthndgMAPD4XFxeFhYXdd9r+/futHgcFBSkoKOhflzl+/HjZ2dlZleXOnVtjxozRmDFj7jtPmTJl9Nlnn6Wx1XgU/zaKofm+shYtWmj16tXy9/eXnZ2dbGxs9Mknn1hGGkxOTlbOnDkt9W1sbCRJp0+flq+vr3r16qXJkydr8eLFSkpKkru7u/r37y9JVqMYpoTvpk2bKiQkJN33AQAAGYUzSQDwFHiUUQwTEhJUsWJFrVixQgcOHNDo0aM1dOhQHTt2TJLUuHFjrV27VufOnVNcXJymTZumuLg4xcbGSroXmt5//33t3btXW7dulSTLGUNGMQQAPAsISc+AJ3Wzd2xsrObPn6969erJ29tbb775pv7880/L9Li4OI0dO1Z169aVp6en3nzzTZ06dUqSNHv2bHl4eFj9Va5cWU2bNk3fjQeyiUcZxXDMmDEqX768qlevLkdHR3Xo0EHu7u5as2aNJGngwIEqX7683njjDTVr1kyOjo6qUKGC8ubNq0OHDmnatGl677335OzsrOLFi2vgwIFav369oqOjGcUQAPBMICQ9A57Uzd4zZ87U33//rfXr1+vnn39WxYoVrS7bGjlypA4fPqw1a9Zo165dKlu2rPr06SNJ6tmzp/bv32/5W7ZsmXLnzq1Ro0ZlyD4AnnaPMophZGSkZRCGFPb29nJwcJAkXb58We3atdNPP/2kbdu26fXXX9dff/2lqlWr6u+//1ZSUpLVKIUODg6ysbGRnZ0doxgCAJ4JhKRs7kne7J0yPYWtra3lcp+oqCh98803mjBhgp577jk5Ojqqf//++uijj1IdPMXHxys4OFhvvfWWXnzxxXTcevxX/7ysC5nvUUYx9PPz05IlS3T48GElJydr8+bN2r17t/z9/SXdO2M8e/Zsy48Ajxo1SlWqVFH16tXl6ekpJycnjR8/XnFxcYqKitLkyZPVuHFjywiHjGIIAMjuCEnZ3L/d7G3WokULubi4yN/fX1WqVFGfPn00ceJEy83e3bp1U0REhOrUqSN3d3etW7dOU6dOlSQdOnRIefLk0YEDB9SiRQvLb6sUKFDAclN4is8++0wODg7q0aNH+m58JjFM37A/jezs7FS5cuVUgzY8bZ72friftI5iGBQUpC5duqhXr17y9vbW3LlzNXPmTFWqVEmS1K9fP+XOnVsvv/yymjRpIhsbG4WHh0u6N0rh/PnzdebMGdWrV09t27ZV6dKlNX78eMt0RjEEAGR3jG6Xzf3bzd7mEbFSbvYeN26cKlasqPXr12vo0KEqW7as3NzclJiYqFq1amnYsGHKmzevPv74YwUGBmrdunW6efOmbt++re+++05ffPGFHBwcNHr0aPXs2VNr1qyxHHBHR0dr0aJFmjBhwlN/EP4gNra2ilm9WklXrmR2U55ZdoULy7l9+8xuxhOX1lEM7e3t1atXL/Xq1eu+dXPnzq2goCC5u7vf93VYtWrV+16Sm4JRDAEA2R0hKZt71Ju9a9asqerVq0uSOnTooG+//VZr1qxRv379FBISon79+qlIkSKys7PTsGHD5O3trZ9//lmOjo5KSkpSaGioChYsKEkaPHiwateurdOnT6tcuXKSpE2bNilv3rzy8/NL703PVElXrij54sXMbgYAAAD+Ay63y+ae1M3eMTExunXrltWoeCm/v+Lg4GAJQeb5k5KSJMnqnqTvvvtOrVq1SnUJHgAAAJBVEJKyuSd1s3e+fPlUs2ZNLVu2TFFRUYqLi9Mnn3yiAgUKyNPTU+XKlZO3t7eGDx+ua9eu6c6dO5o4caKqVKmi8uXLS7oXlvbv3y9vb++M3g0A/oHBOQAAeDBC0jPgSd3sPXXqVLm6uqpt27aqX7++Tp06pfnz58vZ2VmSNGvWLJUvX15t27ZVvXr1FBMTY7kZXJKuX7+u27dvWw0iATytnuaBIRicAwCAh+OepGfAk7rZ28XFRYGBgQ+82TtPnjwaPXr0A9tRsGBBHTt27BFbD2RNDNCRubLr4BwAgKyBkAQA/xEDdAAAkD1xuR0AAAAAmBCSAAAAAMCEkIRHwohYAAAAyO4ISRnsaR6NiRGxAAAA8Cxg4IYMxohYmYsRsQAAQHqLiorSsGHDtGfPHtnZ2al169YKDQ2VvX3qQ+9FixZp0aJFunHjhooXL66goCA1bdpUkpScnCxPT08lJyfL1tZWNjY2kqSff/7Z8hMsKQYMGKCLFy/qiy++sJTt3r1bU6ZM0alTp+Ts7KwmTZqoX79+XBmUBoSkTMCIWACA+8moA6vz589r4sSJ2rt3rwzDkKenpwYPHqySJUtKkjZt2qTw8HCdP39e+fLlU/v27RUUFCRbWy5AAdIiODhYRYoU0c6dO3X16lW9//77Wrhwod59912retu3b9ecOXO0ZMkSlSlTRlu2bFFwcLC+//57lShRQidPnlRiYqLmz58vLy+vB17Ns3LlSn377bfy8vKylF26dEk9e/bU4MGD1aFDB12+fFlBQUGaNGmShg0blq7bnx3wbgcAQBYRHBwsZ2dn7dy5UytXrtSuXbu0cOHCVPVSDqzmzZun33//XUFBQQoODtb58+clyXJg9dlnn2nfvn3av3+/9u/fb/nm+YMPPlC+fPm0detWbd26Vfnz57f8yPiff/6pAQMGKDQ0VPv379fChQv19ddfa82aNRm2H4Cn2dmzZ7Vnzx4NGDBATk5OKlmypAIDA7V06dJUdf/66y8ZhmH5s7Ozk4ODg+WLkYMHD8rNze2+X5SkOHnypMLDw9WxY0er8oiICPn5+alTp06ys7NT0aJF1aZNG/32229PdoOzKc4kAQCQBaQcWO3YscPqwOqTTz5J9e3z4xxY3bx5Uy4uLurTp48lNL3xxhtq06aNbt68qYoVK+rXX39V7ty5lZycrOvXryshIUEFChRI/50AZAMnTpxQ/vz5VaRIEUtZ2bJlFRkZqVu3bilv3ryW8hYtWmj16tXy9/eXnZ2dbGxs9Mknn8jV1VXSvddybGysPvzwQ12/fl1ly5ZVv379VLNmTUlSbGysQkJCNGLECP3xxx86ffq0ZdleXl5WZ5aSk5P1/fffq0qVKum9C7IFQhIAAFlARh1Y5cuXT/Pnz7da95YtW1S8eHHly5dPkpQ7d27FxsbKy8tLCQkJat68uerXr58BewF4+t25cyfVPT8pj2NiYqxeywkJCapYsaLGjRunihUrav369Ro6dKjKli0rNzc35cyZU9WrV5efn5/q1Kmj5cuX65133tG6detUsmRJjR49WnXr1pWvr6/++OOPB7YpISFBw4YNU0REhCZNmpQ+G57NcLkdAABZwL8dWJmlHFitWLFCBw4c0OjRozV06FAdO3ZMkiwHVn379tWPP/4oPz8/vfPOO4qIiEi13mXLlmnBggUaO3asVbmjo6N+//13bd68WSdPntSYMWOe5OYC2Zazs7Pu3r1rVZbyOFeuXFblY8aMUfny5VW9enU5OjqqQ4cOcnd3t1zeOmjQII0dO1YFCxZUzpw59c4776hYsWLavn271q1bpz///FN9+/Z9aHsuX76sbt266ejRo1q2bJnVFzF4MEISAABZQEYdWKWIj4/XqFGjNHXqVM2ZM0d16tSxWoetra0cHR31wgsvKDAwUN9++216bDaQ7ZQvX143btzQ1atXLWWnTp2Sq6ur8uTJY1U3MjJS8fHxVmX29vZycHCQJH366ac6cuSI1fT4+HjlyJFD33zzjU6fPq06derIy8tLc+fO1b59++Tl5aXIyEhJ0h9//KH27duraNGiWr58uYoWLZoem5wtEZIAAMgCMurASpKuXbumrl276sCBA1q5cqVefPFFS71Nmzbp1VdfTTVvyqV4AB6udOnS8vT01Pjx4xUdHa2IiAiFh4crICAgVV0/Pz8tWbJEhw8fVnJysjZv3qzdu3fL399fknT8+HFNmDBBN27cUHx8vGbMmKHo6Gg1btxY8+fP1/79+7V3717t3btXPXr0kKenp/bu3atixYopIiJCb7/9tjp27KhJkyYx7PcjIiQBAJAFZNSBVUJCgt59913lzp1by5Ytswz7ncLd3V3Hjx/X559/rqSkJJ04cUIzZ85MFZwAPFhYWJgSExPVqFEjderUSfXq1bOMIOnh4aF169ZJkoKCgtSlSxf16tVL3t7emjt3rmbOnKlKlSpJkiZMmKCSJUtq0KBBql27tvbs2aPPP/9c+fPn/9c2LFq0SLdv39bChQvl4eFh+WvRokW6bXd2YmMYhpHZjUhPSUlJOnDggNzd3R84tnxGuz1nDr+TlElsXV2V57330n099HHmop+zv4zq44x29epVjR49Wrt375atra3atm2r/v37y87OTh4eHho1apRat26txMREzZo1S2vWrNHNmzdVqlQphYSEqF69epKkGzduaMKECdq6dasSEhJUvXp1DRkyRBUrVtR3332nXr16KUeOHKk+Fzds2KBixYrp999/18cff6wTJ07IxcVFr776qt544w1+JymLyYrHOHjy6OcnK637k9HtAADIIlxcXBQWFnbfafv377f8b29vr169eqlXr173rZs/f36NHz/+vgcCTZo0sQzw8CA1a9bU8uXL/8MWAED2wFdCAAAAAGBCSAIAAAAAE0ISAAAAkIUxMl3GIyQBAJBNcWAFSEZycmY34bHY2dmpcuXKT/WgDU9jHzBwAwAA92EkJ8vmKR7NLeXA6mn2tPcBsgYbW1vFrF6tpCtXMrspzyS7woXl3L59ZjfjkRGSAAC4Dw6sMtfTemCFrCnpyhV+sgGPhJAEAMADcGAFAM8mzmEDAAAAgAkhCQAAAABMCEkAAAAAYEJIAgAAAAATQhIAAAAAmBCSAAAAAMCEkAQAAAAAJoQkAAAAADAhJAEAAACACSEJAAAAAEwISQAAAABgQkgCAAAAABNCEgAAAACY2Gd2AwAAAJ4lUVFRGjZsmPbs2SM7Ozu1bt1aoaGhsre3Pix79913tW/fPquymJgYde7cWaNHj1ZsbKzmz5+vAwcOKCEhQZUrV9bgwYNVsWJF7d27V927d7eaNyEhQQkJCdqxY4fWrFmjOXPmWE2Pi4tTyZIltWXLlvTZcOApQkgCAADIQMHBwSpSpIh27typq1ev6v3339fChQv17rvvWtWbN2+e1eOVK1dqxowZCgoKkiTNnDlTf//9t9avX688efJo8uTJCgoK0g8//CAvLy/t37/fMm90dLQ6d+6sFi1aqEiRIurZs6d69uxpmf7nn3/qjTfe0KhRo9Jxy4GnB5fbAQAAZJCzZ89qz549GjBggJycnFSyZEkFBgZq6dKlD53vr7/+0pgxYzRp0iQ999xzljLDMCx1bG1t5eTkdN/5x44dqyJFiigwMDDVtPj4eAUHB+utt97Siy+++BhbB2QfmRKSoqKiFBgYKC8vL/n4+GjcuHFKTEy8b91FixbJz89PNWvWVKtWrTgFDAAAnlonTpxQ/vz5VaRIEUtZ2bJlFRkZqVu3bj1wvlGjRqlt27by8vKylHXr1k0RERGqU6eO3N3dtW7dOk2dOjXVvHv37tXGjRs1ZsyY+y77s88+k4ODg3r06PHfNwzIZjIlJAUHB8vZ2Vk7d+7UypUrtWvXLi1cuDBVve3bt2vOnDmaN2+efv/9dwUFBSk4OFjnz5/P+EYDAAA8pjt37qQ625PyOCYm5r7z7N27V//3f/9nucwuRWJiomrVqqVt27Zpz549atSokQIDAxUXF2dVb/r06Xr11VdVvHjxVMuOjo7WokWLFBwcLDs7u8fZNCBbyfCQ9CinmVNOI6f82dnZycHBIdWNjQAAAE8DZ2dn3b1716os5XGuXLnuO89XX32l5s2bq3DhwpayhIQEhYSEyNfXV0WKFFHu3Lk1bNgwXbp0ST///LOl3rlz57Rnzx517dr1vsvetGmT8ubNKz8/v8fdNCBbyfC08W+nmfPmzWspb9GihVavXi1/f3/Z2dnJxsZGn3zyiVxdXTO62QAAAI+tfPnyunHjhq5evSoXFxdJ0qlTp+Tq6qo8efKkqp+YmKgff/xRM2fOtCqPiYnRrVu3rG5XSDlWcnBwsJRt2bJFNWvWVIkSJe7bnu+++06tWrWSjY3Nk9g8INvI8JD0b6eZzSEpISFBFStW1Lhx41SxYkWtX79eQ4cOVdmyZeXm5vZI601KSnr8xj8BnMrOGtLz+UAfZx30c/ZHH2d/WeXz+0kpWbKkatasqXHjxmnUqFG6fv26Zs6cqfbt2993W48ePaq4uDjVqFHDanru3LlVs2ZNLVu2TI0aNVK+fPkUFhamAgUKyN3d3VJ337598vT0vO+yDcPQ/v379cYbb2S7/WzGazlryCrPsbS2I8ND0qOcZh4zZoxq1qyp6tWrS5I6dOigb7/9VmvWrNGgQYMeab0HDx58jFY/GU5OTqpcuXJmNwOSjh07lup5+CTQx1kL/Zz90cfZX3r1cWbq3r27Pv/8czVs2FC2traqV6+e6tSpowMHDuitt97SO++8o5deekmStHv3bjk7O+vo0aP3Xc7SpUvVpk0bJSUlqVy5curbt6+OHz9uqXPixAmVLl1aBw4cSDX/rVu3dPv2bV2/fv2+07MDXstZx9P2Ws7wkPQop5kjIyNVtWpVqzJ7e3ur08hpVa1aNb5JgMWjnonE04l+zv7o4+wvu/axr6/vfcvNv20kSe7u7nrvvffuWzcpKUn58uV76DHOd99999B2HDlyJA2tBR5fVnktJyUlpenkSYaHpNKlS8vT01Pjx4/X6NGjdf36dYWHhysgICBVXT8/Py1ZskQNGzZUpUqV9N1332n37t3q27fvI6/Xzs6OkAQLngvPBvo5+6OPsz/6+N9xjIOnwdP2HM2UYeLCwsI0evRoNWrUSLa2tmrbtq3lx808PDw0atQotW7dWkFBQbKzs1OvXr108+ZNlSpVSjNnzlSlSpUyo9kAAAAAngGZEpJcXFwUFhZ232nm08z29vbq1auXevXqlVFNAwAAeGr8czAsAE9GpvyYLAAAQFZgJCdndhP+Mzs7O1WuXPmpu4zpn57mPkD2xa+yAgCAZ5aNra1iVq9W0pUrmd2UZ5Jd4cJybt8+s5sBpEJIAgAAz7SkK1eUfPFiZjcDQBbC5XYAAAAAYEJIAgAAAAATQhIAAAAAmBCSAAAAAMCEkAQAAAAAJoQkAAAAADAhJAEAAACACSEJAAAAAEwISQAAAABgQkgCAAAAABNCEgAAAACYEJIAAAAAwISQBAAAAAAmhCQAAAAAMCEkAQAAAIAJIQkAAAAATAhJAAAAAGBCSAIAAAAAE0ISAAAAAJgQkgAAAADAhJAEAAAAACaEJAAAAAAwISQBAAAAgAkhCQAAAABMCEkAAAAAYEJIAgAAAAATQhIAAAAAmBCSAAAAAMCEkAQAAAAAJoQkAAAAADAhJAEAAACACSEJAAAAAEwISQAAAABgQkgCAAAAABNCEgAAAACYEJIAAAAAwISQBAAAAAAmhCQAAAAAMCEkAQAAAIAJIQkAAAAATAhJAAAAAGBCSAIAAAAAE0ISAAAAAJgQkgAAAADAhJAEAAAAACaEJAAAAAAwISQBAAAAgAkhCQAAAABMCEkAAAAAYEJIAgAAAAATQhIAAAAAmBCSAAAAAMCEkAQAAAAAJoQkAAAAADAhJAEAAACACSEJAAAAAEwISQAAAABgQkgCAAAAABNCEgAAAACYEJIAAAAAwISQBAAAAAAmhCQAAAAAMCEkAQAAAIAJIQkAAAAATAhJAAAAAGBCSAIAAAAAE0ISAAAAAJgQkgAAAADAhJAEAAAAACaEJAAAAAAwISQBAAAAgAkhCQAAAABMCEkAAAAAYEJIAgAAAAATQhIAAAAAmBCSAAAAAMCEkAQAAAAAJoQkAAAAADAhJAEAAACACSEJAAAAAEwyJSRFRUUpMDBQXl5e8vHx0bhx45SYmHjfunv27FHHjh3l4eEhX19fzZkzJ4NbCwAAAOBZkikhKTg4WM7Oztq5c6dWrlypXbt2aeHChanqnTp1Sj169NBrr72m33//XXPmzNGCBQu0efPmjG80AAAAgGdChoeks2fPas+ePRowYICcnJxUsmRJBQYGaunSpanqfvnll2rUqJHatWsnGxsbVaxYUcuXL5enp2dGNxsAAADAM8I+o1d44sQJ5c+fX0WKFLGUlS1bVpGRkbp165by5s1rKf/jjz9Up04d9e3bVz///LMKFiyobt26qXPnzo+83qSkpCfS/sdlZ2eX2U2A0vf5QB9nHfRz9kcfZ3/p/flNP2cNvJazv6xyLJ7WdmR4SLpz546cnJysylIex8TEWIWkmzdvavHixfr000/18ccfa//+/XrvvfeUL18+NWvW7JHWe/Dgwcdv/GNycnJS5cqVM7sZkHTs2DHdvXv3iS+XPs5a6Ofsjz7O/tKrjyX6OSvhtZz9pedrOT1keEhydnZOtYNSHufKlcuq3NHRUY0aNVKDBg0kSd7e3mrTpo02bdr0yCGpWrVqfJMACzc3t8xuAjIA/Zz90cfZH338bKCfs7+s0sdJSUlpOnmS4SGpfPnyunHjhq5evSoXFxdJ9wZocHV1VZ48eazqli1bVvHx8VZlSUlJMgzjkddrZ2dHSIIFz4VnA/2c/dHH2R99/Gygn7O/p62PM3zghtKlS8vT01Pjx49XdHS0IiIiFB4eroCAgFR1X3nlFf3444/65ptvZBiGfvvtN61fv15t2rTJ6GYDAAAAeEZkyhDgYWFhSkxMVKNGjdSpUyfVq1dPgYGBkiQPDw+tW7dOklS7dm2Fh4dr8eLF8vT01ODBgxUaGqpGjRplRrMBAAAAPAMy/HI7SXJxcVFYWNh9p+3fv9/qsa+vr3x9fTOiWQAAAACQOWeSAAAAACCrIiQBAAAAgAkhCQAAAABMCEkAAAAAYEJIAgAAAAATQhIAAAAAmBCSAAAAAMCEkAQAAAAAJoQkAAAAADAhJAEAAACACSEJAAAAAEwISQAAAABgQkgCAAAAABNCEgAAAACYEJIAAAAAwISQBAAAAAAmhCQAAAAAMCEkAQAAAIAJIQkAAAAATAhJAAAAAGBCSAIAAAAAE0ISAAAAAJgQkgAAAADAhJAEAAAAACaEJAAAAAAwsU9rxa5du8rGxuahdRYvXvzYDQIAAACAzJTmkOTj45Oe7QAAAACALCHNISkoKCg92wEAAAAAWUKaQ9LgwYP/tc6ECRMeqzEAAAAAkNkYuAEAAAAATNJ8JomzRAAAAACeBWkOSSni4+O1fv16Xbp0ScnJyZKkhIQEHT9+XLNmzXriDQQAAACAjPTIIWnIkCHauXOnChQooISEBDk7O+vEiRNq27ZtOjQPAAAAADLWI4eknTt3atmyZbp27ZqWLVumyZMna8GCBfrjjz/So30AAAAAkKEeeeCG5ORklSlTRmXKlNHRo0clSV26dNHevXufeOMAAAAAIKM9ckhydXVVRESEChYsqKioKMXExMgwDN25cyc92gcAAAAAGeqRL7dr1aqVXnvtNa1cuVINGjTQ+++/rxw5cqhq1arp0T4AAAAAyFCPHJJ69OihkiVLKk+ePBo2bJgmTZqk27dva9iwYenRPgAAAADIUI8ckiQpb968iouLU4ECBdSwYUM5ODioZMmST7ptAAAAAJDhHvmepKVLl6pPnz66cuWKJCkqKkohISFau3btk24bAAAAAGS4Rw5Jn3/+uRYtWqQKFSpIktq3b6/58+fzQ7IAAAAAsoVHDklRUVGqVKmSVVnlypUVFRX1xBoFAAAAAJnlkUNSuXLl9M0331iVrV+/XmXKlHlijQIAAACAzPLIAzcEBwfr/fff19dff61ixYrp77//1pEjRzR37tz0aB8AAAAAZKhHPpNUt25dffPNN6pbt65y586t+vXra/369apVq1Z6tA8AAAAAMtR/GgL8hRdeUNeuXRUREaFKlSopKSnpSbcLAAAAADLFI59JunPnjvr16ycfHx+9/vrrOnv2rBo3bqy//vorPdoHAAAAABnqkUPSxx9/rJiYGG3atMnyI7INGzbUuHHj0qN9AAAAAJChHvlyu23btmn9+vXKly+fbGxs5ODgoEGDBql+/frp0T4AAAAAyFCPfCYpOTlZjo6OkiTDMFKVAQAAAMDT7JFD0osvvqjRo0fr7t27srGxkSRNnTqV0e0AAAAAZAuPHJIGDx6sU6dOydvbW7dv35aHh4d+++03hYaGpkf7AAAAACBDPfI9SXZ2dvrqq6908OBBXbhwQa6urqpQoYKmTJmiYcOGpUcbAQAAACDDpPlM0tGjR9WoUSPVrl1br7zyikqVKqXmzZvL2dlZnTt31rp169KznQAAAACQIdIcksaNG6cKFSpo1qxZyp07t2bPnq1ff/1Vr776qvLkyaM1a9akZzsBAAAAIEOk+XK7o0eP6vvvv1fBggVVsWJFvf7661q1apVef/11BQcHy9b2kW9vAgAAAIAsJ80hKTk5WQULFpQkubq66uLFi+rbt6/efvvtdGscAAAAAGS0NJ/+SRnuO4WDg4O6du36xBsEAAAAAJnpP18j5+DgIAcHhyfZFgAAAADIdGm+3C4xMVFr1661PE5ISLB6LElt27Z9Qs0CAAAAgMyR5pDk4uKisLAwy+MCBQpYPbaxsSEkAQAAAHjqpTkkbd26NT3bAQAAAABZAuN2AwAAAIAJIQkAAAAATAhJAAAAAGBCSAIAAAAAE0ISAAAAAJgQkgAAAADAhJAEAAAAACaEJAAAAAAwISQBAAAAgAkhCQAAAABMCEkAAAAAYEJIAgAAAAATQhIAAAAAmBCSAAAAAMCEkAQAAAAAJoQkAAAAADAhJAEAAACACSEJAAAAAEwISQAAAABgQkgCAAAAAJNMCUlRUVEKDAyUl5eXfHx8NG7cOCUmJj50nuPHj6tGjRravXt3BrUSAAAAwLMoU0JScHCwnJ2dtXPnTq1cuVK7du3SwoULH1j/7t276tevn2JjYzOukQAAAACeSRkeks6ePas9e/ZowIABcnJyUsmSJRUYGKilS5c+cJ5Ro0bp5ZdfzsBWAgAAAHhWZXhIOnHihPLnz68iRYpYysqWLavIyEjdunUrVf21a9fq7NmzCgoKyshmAgAAAHhG2Wf0Cu/cuSMnJyerspTHMTExyps3r6X81KlT+vTTT7Vs2TLZ2dk91nqTkpIea/4n5XG3A09Gej4f6OOsg37O/ujj7C+9P7/p56yB13L2l1WOxdPajgwPSc7Ozrp7965VWcrjXLlyWcri4uIUEhKiIUOGqFixYo+93oMHDz72Mh6Xk5OTKleunNnNgKRjx46leh4+CfRx1kI/Z3/0cfaXXn0s0c9ZCa/l7C89X8vpIcNDUvny5XXjxg1dvXpVLi4uku6dMXJ1dVWePHks9Q4ePKgzZ85o6NChGjp0qKW8Z8+eatOmjUaOHPlI661WrRrfJMDCzc0ts5uADEA/Z3/0cfZHHz8b6OfsL6v0cVJSUppOnmR4SCpdurQ8PT01fvx4jR49WtevX1d4eLgCAgKs6nl5eemPP/6wKnNzc9Ps2bPl4+PzyOu1s7MjJMGC58KzgX7O/ujj7I8+fjbQz9nf09bHmTIEeFhYmBITE9WoUSN16tRJ9erVU2BgoCTJw8ND69aty4xmAQAAAEDGn0mSJBcXF4WFhd132v79+x8437Fjx9KrSQAAAAAgKZPOJAEAAABAVkVIAgAAAAATQhIAAAAAmBCSAAAAAMCEkAQAAAAAJoQkAAAAADAhJAEAAACACSEJAAAAAEwISQAAAABgQkgCAAAAABNCEgAAAACYEJIAAAAAwISQBAAAAAAmhCQAAAAAMCEkAQAAAIAJIQkAAAAATAhJAAAAAGBCSAIAAAAAE0ISAAAAAJgQkgAAAADAhJAEAAAAACaEJAAAAAAwISQBAAAAgAkhCQAAAABMCEkAAAAAYEJIAgAAAAATQhIAAAAAmBCSAAAAAMCEkAQAAAAAJoQkAAAAADAhJAEAAACACSEJAAAAAEwISQAAAABgQkgCAAAAABNCEgAAAACYEJIAAAAAwISQBAAAAAAmhCQAAAAAMCEkAQAAAIAJIQkAAAAATAhJAAAAAGBCSAIAAAAAE0ISAAAAAJgQkgAAAADAhJAEAAAAACaEJAAAAAAwISQBAAAAgAkhCQAAAABMCEkAAAAAYEJIAgAAAAATQhIAAAAAmBCSAAAAAMCEkAQAAAAAJoQkAAAAADAhJAEAAACACSEJAAAAAEwISQAAAABgQkgCAAAAABNCEgAAAACYEJIAAAAAwISQBAAAAAAmhCQAAAAAMCEkAQAAAIAJIQkAAAAATAhJAAAAAGBCSAIAAAAAE0ISAAAAAJgQkgAAAADAhJAEAAAAACaEJAAAAAAwISQBAAAAgAkhCQAAAABMCEkAAAAAYEJIAgAAAAATQhIAAAAAmBCSAAAAAMCEkAQAAAAAJoQkAAAAADAhJAEAAACACSEJAAAAAEwISQAAAABgQkgCAAAAAJNMCUlRUVEKDAyUl5eXfHx8NG7cOCUmJt637rJly9S0aVN5eHioadOmWrp0aQa3FgAAAMCzJFNCUnBwsJydnbVz506tXLlSu3bt0sKFC1PV++GHHzRlyhR99NFH+v333zVx4kRNnTpVW7ZsyfhGAwAAAHgmZHhIOnv2rPbs2aMBAwbIyclJJUuWVGBg4H3PEF26dEndu3eXu7u7bGxs5OHhIR8fH/32228Z3WwAAAAAzwj7jF7hiRMnlD9/fhUpUsRSVrZsWUVGRurWrVvKmzevpbxLly5W80ZFRem3337T4MGDM6y9AAAAAJ4tGR6S7ty5IycnJ6uylMcxMTFWIcnsypUreu+991S1alW1bNnykdeblJT06I1NB3Z2dpndBCh9nw/0cdZBP2d/9HH2l96f3/Rz1sBrOfvLKsfiaW1HhockZ2dn3b1716os5XGuXLnuO8+BAwfUp08feXl5acKECbK3f/RmHzx48NEb+4Q5OTmpcuXKmd0MSDp27Fiq5+GTQB9nLfRz9kcfZ3/p1ccS/ZyV8FrO/tLztZweMjwklS9fXjdu3NDVq1fl4uIiSTp16pRcXV2VJ0+eVPVXrlypsWPHqnfv3nr77bf/83qrVavGNwmwcHNzy+wmIAPQz9kffZz90cfPBvo5+8sqfZyUlJSmkycZHpJKly4tT09PjR8/XqNHj9b169cVHh6ugICAVHW3bNmikSNHatasWapXr95jrdfOzo6QBAueC88G+jn7o4+zP/r42UA/Z39PWx9nyhDgYWFhSkxMVKNGjdSpUyfVq1dPgYGBkiQPDw+tW7dOkjRjxgwlJSWpd+/e8vDwsPwNHz48M5oNAAAA4BmQ4WeSJMnFxUVhYWH3nbZ//37L/+vXr8+oJgEAAACApEw6kwQAAAAAWRUhCQAAAABMCEkAAAAAYEJIAgAAAAATQhIAAAAAmBCSAAAAAMCEkAQAAAAAJoQkAAAAADAhJAEAAACACSEJAAAAAEwISQAAAABgQkgCAAAAABNCEgAAAACYEJIAAAAAwISQBAAAAAAmhCQAAAAAMCEkAQAAAIAJIQkAAAAATAhJAAAAAGBCSAIAAAAAE0ISAAAAAJgQkgAAAADAhJAEAAAAACaEJAAAAAAwISQBAAAAgAkhCQAAAABMCEkAAAAAYEJIAgAAAAATQhIAAAAAmBCSAAAAAMCEkAQAAAAAJoQkAAAAADAhJAEAAACACSEJAAAAAEwISQAAAABgQkgCAAAAABNCEgAAAACYEJIAAAAAwISQBAAAAAAmhCQAAAAAMCEkAQAAAIAJIQkAAAAATAhJAAAAAGBCSAIAAAAAE0ISAAAAAJgQkgAAAADAhJAEAAAAACaEJAAAAAAwISQBAAAAgAkhCQAAAABMCEkAAAAAYEJIAgAAAAATQhIAAAAAmBCSAAAAAMCEkAQAAAAAJoQkAAAAADAhJAEAAACACSEJAAAAAEwISQAAAABgQkgCAAAAABNCEgAAAACYEJIAAAAAwISQBAAAAAAmhCQAAAAAMCEkAQAAAIAJIQkAAAAATAhJAAAAAGBCSAIAAAAAE0ISAAAAAJgQkgAAAADAhJAEAAAAACaEJAAAAAAwISQBAAAAgAkhCQAAAABMCEkAAAAAYEJIAgAAAAATQhIAAAAAmBCSAAAAAMCEkAQAAAAAJoQkAAAAADAhJAEAAACACSEJAAAAAEwISQAAAABgkikhKSoqSoGBgfLy8pKPj4/GjRunxMTE+9bdvn27WrVqJXd3dzVv3lzbtm3L4NYCAAAAeJZkSkgKDg6Ws7Ozdu7cqZUrV2rXrl1auHBhqnpnzpxRr1691KdPH+3du1e9evVScHCwLl26lPGNBgAAAPBMyPCQdPbsWe3Zs0cDBgyQk5OTSpYsqcDAQC1dujRV3TVr1sjLy0svv/yy7O3t5e/vL29vb3311VcZ3WwAAAAAzwj7jF7hiRMnlD9/fhUpUsRSVrZsWUVGRurWrVvKmzevpfzkyZOqUKGC1fzlypXTn3/+meb1GYYhSYqPj5ednd1jtv7x2dnZSc89J8OW28EyhYuLkpKSlJSUlG6roI+zAPo5+6OPs78M6GOJfs50vJazvwx6LadVSjtSMsKDZHhIunPnjpycnKzKUh7HxMRYhaT71c2ZM6diYmLSvL7k5GRJ0pEjR/5rk5+855+/94fMceBA+q+DPs589HP2Rx9nfxnRxxL9nNl4LWd/GfVafgQpGeFBMjwkOTs76+7du1ZlKY9z5cplVe7k5KTY2FirstjY2FT1Hsbe3l7VqlWTra2tbGxs/mOrAQAAADztDMNQcnKy7O0fHoMyPCSVL19eN27c0NWrV+Xi4iJJOnXqlFxdXZUnTx6ruhUqVNDhw4etyk6ePKmqVaumeX22trZydHR8/IYDAAAAeCZk+MWZpUuXlqenp8aPH6/o6GhFREQoPDxcAQEBqeq2bt1ae/bs0caNG5WYmKiNGzdqz549atOmTUY3GwAAAMAzwsb4t7uW0sHVq1c1evRo7d69W7a2tmrbtq369+8vOzs7eXh4aNSoUWrdurUkaefOnZo0aZLOnTun4sWLa8CAAfL19c3oJgMAAAB4RmRKSAIAAACArIqxEAEAAADAhJAEAAAAACaEJAAAAAAwISQh3cTFxenixYuZ3YxsIykpSREREZndDAAAkI7OnDmT2U2ACElPHT8/P1WrVk0eHh7y8PCQu7u7XnrpJX300Uf/+svBGe21117TL7/8ktnNeCLc3Ny0e/fudFm2h4eH9u7d+6/1QkJCtHbtWklSZGSkPDw8FBkZ+cjrc3NzU/Xq1a2eQ97e3urevftTF8Jmz56td999N7Obkelu3rypkSNHytfX1/KeEBoaqosXL2r27NmqW7euEhISUs13+vRpVaxYUUePHtX06dPl5uamvn37pqoXHx+vF198UW5ubhmxOU8lNzc39ejRQ/8cC2n16tXy8/NL0zLWrVunFi1aPPG2TZ8+XZUqVbK85mvUqKEmTZpo6dKlT3xd2c39PnPbtGmjFStWPJHlp7XP0+u5MXz4cMu2VatWTRUrVrQ8TutnU0a53+fwqlWrVK1aNX355Zf3nWf37t1yc3PT3LlzU00bNGiQBg0alC5tfRxbt27VO++888DpXbt2la+vr65fv25Vfv78ebm5uen8+fP/uo5HOYZI2YcPMn36dHXt2vVfl/M0yvAfk8XjGzVqlNq3b295fOzYMXXr1k1OTk7q3bt3JrbM2j9fwLi//fv3p6meeX8WK1YszfPdz2effSYfHx/L4/Pnz6tv374KDQ194IdNVtSzZ8/MbkKWEBISojx58mjlypUqXLiwrl69qnHjxumtt97S0qVLFR4erq1bt6pp06ZW8y1fvlxeXl6qVKmSfvjhBxUoUEA//PCDbt++bfXj3lu3br1vyIK17du3a968eerevft/mr9169aWn7940ry8vPTFF19Iuvdr87t27VKPHj1UtmxZvfjii+myzuzC/JkbHx+vn376SYMHD9b169fVo0ePx1p2Wvs8vZ4bo0eP1ujRoyXdC/QzZszQ1q1bn/h60sPcuXM1a9YshYWFqWHDhg+tO23aNHl5ealmzZoZ1Lr/7saNG6m+bPmnixcvKjQ0VHPmzJGNjc0jr+NxjyGeFZxJygbc3Nzk7e2tI0eOKD4+XtOmTVOjRo1Uq1Ytde/eXWfPnrWqO3bsWPn4+FgOMNevX6+WLVvKw8NDzZs318aNGy31N2zYoFatWsnT01Pt27fX//73P8u0rl27auLEiWrfvr3c3d3Vvn17y7dOb7/9tiIjIzVixAjLb2L5+vqqX79+8vLy0ty5c5WcnKy5c+fq5ZdflqenpwICArRz507L8v38/DRnzhy1bdtWHh4eatu2rX799df03p3/yYoVK9SiRQvVrFlTrVq10rp16yzTYmNjNWLECNWqVUu+vr6aOnWq/Pz8LN+Imb8d27Jli1q0aCFPT081b95c4eHhkqShQ4dq7969mjNnjnr27JnqG6OIiAj17NlTnp6eql27tkaOHKn4+Pg0t79EiRJq3bq1jh49aik7d+6cevbsKR8fHzVs2FCffvqp1TI3bNigpk2bysvLS++8846GDRtm+VZu0KBB6t27t5o3b64XX3xR586d09WrV9W/f3/VrVtXL730koYPH67o6GhJUmJiokaOHKm6devKx8dHr732mvbt2ydJio6OVkhIiHx8fFS3bl298847OnXqlKTU32D98MMPat++vWrWrKmmTZtq4cKFljOsgwYN0vDhw9WzZ095eHioUaNGWrx4cZr3UVa2b98+NW7cWIULF5Ykubi4aMiQIapRo4YkqUWLFvr666+t5omNjdWaNWv0xhtvWMrKly+vF154weo9QLr3bW16fIud3XTt2lXTpk3T77///sA6W7du1SuvvKLatWurRo0aev311y2X1pjPOnXp0kVTpkyxmrdjx46aN2+eJOnw4cPq2rWrvL291aRJEy1cuPBfD6xS2NjYqE6dOqpQoYIOHTok6V5wmjt3rlq1aiUvLy95e3urX79+io2N1aVLl1S5cmWr7bp69aqqVKmic+fOyTAMLV682PJ+8Nprr1mWKz34fe1p5OjoqCZNmig0NFQzZsywvIc97P1Nkn7++WcFBATIw8NDfn5+WrJkiSTrPn/Y++A/z0ju3btXXbp0kZeXl/z8/DR16lTL+/P06dPVu3dv9e/fX15eXqpfv74mT578n7Y35bNm4sSJ8vb21qhRoyQ9/Njg345DHpdhGBo7dqwWLVqkxYsX/2tAkqRXX31Vffv2feiXt7/88osCAgLk5eWlFi1aWH2OR0dH68MPP1STJk3k7u6uevXqafbs2Zbpfn5+Gj58uOrWrau2bdsqOTn5oa/RS5cu6d1331WtWrVUv359BQUF6fLly9q9e7dGjBhhOdNz6dKl+7a1bdu2+v333y3vB/cTHR2t0aNHy9fXV7Vr11ZISIiuXr0qKfVZp/Pnz+udd95RzZo11axZMy1cuDDV2aP58+ercePGcnd3V+/eva2e3zExMRo0aJB8fHzUvHlzy1Uv0r3Pmo8//li+vr7y9vZW165d9ccff1im//O49GGf+RnOwFOlYcOGxqpVqyyP4+PjjV9//dXw9vY2Fi9ebEycONFo27atce7cOSM2NtaYPn264efnZ8TGxhqGYRgVKlQwunfvbsTExBg3b940fv31V6Nq1arGTz/9ZCQlJRnbt283qlSpYpw4ccL46aefDE9PT2PPnj1GYmKisXXrVsPd3d04fvy4YRiG8frrrxvu7u7Grl27jLi4OCM8PNzw8vIyrl27lqqtv/76q1GhQgVjxowZRnx8vHH79m0jLCzMqF+/vnHo0CEjISHB2LBhg1G1alXj//7v/yzzN27c2Dhz5owRExNjhIaGGk2bNs3I3W1RoUIF49dff73vtFWrVhk1a9Y0fvnlFyMxMdH45ZdfjJo1axrfffedYRiGMWzYMKNdu3ZGZGSkER0dbQwYMMBqeSn/371716hWrZql/PDhw4a7u7tlf7z++utGWFiYYRiGERERYVSoUMGIiIgwEhISjMaNGxsffvihER0dbVy9etVo06aNMWnSpDRvy6lTp4y2bdsavXv3NgzDMO7cuWM0bNjQmDRpkhEbG2tERkYaAQEBlmX+/vvvRpUqVYwff/zRSEhIML777jujcuXKRmhoqGEYhhEaGmq4u7sbx44dM27evGkkJSUZHTt2NAYMGGDcvn3buHbtmvHee+8ZISEhhmEYxsqVK43WrVsbN2/eNBITE40pU6YYrVq1MgzDMKZNm2a8++67xt27d424uDgjNDTU6Nmzp2EYhhEWFma8/vrrhmEYxq5du4wqVaoYGzZsMBISEoxDhw4Z9evXNz7//HNLm6pUqWL873//MxISEoxly5YZlSpVMi5evJjm50FWNXjwYKNmzZrGiBEjjA0bNhjnz5+3mn7o0CGjYsWKVuUrV640GjRoYCQmJhqG8f/35eeff2507tzZUu/ixYuGj4+PsX37dqNChQoZs0FPoZTX1ejRow1fX1/j+vXrhmHce39o2LChYRiG8ffffxtVq1Y1fvzxR8MwDOPatWvGa6+9ZvTv3z9V3TVr1hi+vr5GUlKSYRiGcfLkSaNKlSrGlStXjIsXLxqenp7GkiVLjPj4eOPEiRNG48aNjWXLlt23bebXiWEYRnJysrF7927D29vb8n6+YcMGo27dusbp06ct66tVq5bx9ddfG4ZhGO+++64xfPhwyzLmz59vdOnSxTAMw1iyZInRoEED4+jRo0Z8fLyxYsUKw8vLy7hy5cq/vq9ldf/8zE1x6dIlo0KFCsb27dv/9f3tr7/+MqpWrWqsWLHCSEhIMA4ePGh4eHgYO3bssOrzh70PmuudOnXKqFq1qrFw4UIjLi7OOHPmjNGqVStjzJgxhmHc6283NzdjzZo1RmJiovHTTz8Zbm5uxv79+x+6reZ1pEj5rPnwww+NuLg44+bNm/96bPBvxyH/VYUKFYydO3caISEhRvXq1Y1z58796zwpxx5xcXFGu3btjB49ehjJycmGYdz7TEj5zDp69KhRvXp1Y8uWLUZiYqKxb98+w8fHx9ixY4dhGIYxYsQI48033zRu3rxpJCcnG5s3bzYqVKhgnDlzxjCMe8+TNm3aGDdv3jRu3rz5r6/RgQMHGkOHDrUcD7311luW/rtfP5ilHAts3rzZqFy5srFv3z7DMKyPCwzDMHr16mW8/fbbxtWrV43o6Gjjww8/NDp37mwkJydb1U1MTDT8/f2NQYMGGXfu3DHOnz9vtGnTxvJ+n7IPR40aZcTGxhoXL1406tWrZ8yePdswjHvPtwoVKhhffPGFER8fb/zvf/8zqlSpYvz222+W/dyqVSvjzJkzRlxcnLFw4ULDw8PDuHDhgqVfzcelD/vMz2icSXoKjRo1Sl5eXvLy8lLt2rU1ZswYvfXWW3r99de1fPly9e3bVyVLllSOHDn0wQcfKCEhQT/99JNl/pYtW8rJyUl58+bV2rVr1aRJE/n6+srW1lb169fXl19+qSJFimjJkiV69dVX5e3tLTs7OzVs2FB+fn5avny5ZVkdOnTQiy++KEdHR/Xs2VNOTk7atm3bA9seEBAgBwcH5c6dW6tWrVKPHj1UpUoV2dvby9/fX35+flq5cqVV/VKlSsnJyUmtWrXKkjczrlq1Sp07d1bt2rVlZ2en2rVrq3Pnzlq+fLkSEhK0bt06hYSEqGjRosqVK5eGDx8uOzu7+y4rZ86cWrlypXbt2qWyZctq3759ql69+kPX//vvv+vChQsaMmSIcuXKpUKFCmnGjBnq2LHjA+fp2bOnvLy8VKNGDVWuXFm9e/eWn5+fJk6cKEn66aefFB8fr759+ypHjhwqWrSo+vTpY7mHYdWqVWrSpIn8/Pxkb2+vxo0b6+WXX7Zah7u7uypUqKC8efPq0KFDOnz4sEaMGKHcuXOrQIECCg0N1YYNG3T9+nXlzJlT58+f18qVK3X69Gn16dPH8i1ezpw59eeff2rt2rW6dOmSxo8fr1mzZqXaptWrV6tRo0by9/eXvb29qlSpoh49elg9X1O+mbK3t1eHDh2UlJSkc+fOPXT/Pg3Gjh2r4cOH6++//9bw4cPl5+enxo0bW/ZhlSpV5O7ubvXaWrZsmbp06ZLqudi6dWsdOnRIp0+flnRvv/r7+ytHjhwZt0FPsdDQUBUsWFCDBg1KdWanYMGC2rBhg/z8/BQdHa2LFy+qQIEC9/22uFmzZrpz547lLPPq1avl6+srFxcXrVu3TmXLllWXLl3k4OCgcuXK6Z133nnoPUb79u2zfG5Uq1bNcl9DqVKlJEn169fXypUrVbp0aV27dk3Xr19X/vz5LW3r0KGDNm/ebDlbsWbNGnXo0EGStHTpUr333nuqWLGiHBwcFBAQoLJly1q9hh/1fS2rK1CggKR7l0b92/vbhg0bVKVKFQUEBMje3l5Vq1bVl19+qSpVqlgt82Hvg2br16+Xm5ub3nzzTTk6OqpUqVLq16+fVqxYYTlzXrp0abVt21Z2dnby9fVV4cKFH+vzs23btnJ0dFTevHkfemxgGEaajkP+q2HDhunixYvKkSOHVq9eneb5HB0dNXXqVO3du1fz589PNX358uVq1KiRmjRpIjs7O9WsWVOdOnWyvKZ69eqlqVOnKnfu3Jb1S9Lly5cty2jatKny5s2rvHnz/utrNEeOHNq3b582bNigO3fuaN68efrwww8faV80bdpUnTt3Vt++fXXjxg2raVFRUdqyZYuGDh2qQoUKKVeuXBoyZIgOHjyow4cPW9U9cOCAzpw5o2HDhsnZ2VnFixdXSEhIqvX16tVLOXLkUJEiReTt7W312VmpUiW9/vrrcnBwUN26ddW0aVN98803iouL07fffqt+/fqpVKlScnR01JtvvqkyZcro22+/tcxvPi5N62d+RuCepKfQiBEjrO5JShEVFaWYmBj16dNHtrb/P/8mJCTowoULlsfPPfec5f/Lly+rcuXKVstJ+fC6cOGC9uzZo2XLllmmJSUlWV2/Xrp0acv/NjY2cnV11ZUrVx7YdvO6r169qpIlS1pNL1GihP7880/LYxcXF8v/9vb2ab6cJCM9aDu2bt2qGzdu6O7duypevLhlWsqH6D/lzJlTy5YtU3h4uPr166fo6Gg1bdpUH374ofLly/fA9V+5ckUFChSQk5OT1fofZvbs2fLx8dGdO3c0bdo0bdy4UU2aNLEs48KFC7p27Zq8vb0t8xiGoYSEBEVFRenvv/9O9bwpWbKk5VS+ZN3X58+fV1JSknx9fa3mcXR0VEREhFq0aKGEhAStWLFCU6ZMUaFChdSzZ0+9+uqr6t69uxwdHbVy5UqNHj1aJUuWVL9+/dSkSROrZUVFRalSpUpWZSVKlLB67qdcjiZJDg4OkpTlBjz5L2xtbdWmTRu1adNGhmHo1KlT+uabbzRw4EAVLlxYtWvXtlweGxQUpKNHj+rkyZP3DdIFCxZUgwYNtHbtWoWEhGjNmjWaOnWqbt++nQlb9vRJORhr166dFixYYPVad3Bw0Lfffqvly5fLxsZGFSpUUHR0tOztU38U58yZU61atdLatWtVq1YtrVu3TmPGjJF07/V5+PBheXl5WeonJyc/8MsXSfL09LTckyRJx48fV//+/dW/f3+FhYXJMAx9+umn2rZtmwoWLKhKlSopISHB8p7r5+enESNGaPv27SpWrJguXLhgucftwoUL+uijjzRp0iTL8hMTE1W1atX//L6W1V27dk2SVKhQoX99f7t8+bKKFStmNa1ixYqplvmw90GzqKio+37mxMbGKioqSpL1e51077n3OO915vfzhx0bXLt2LU3HIf9VjRo19PHHH+uXX37R+++/r0qVKlk+C9atW6cRI0ZY6o4aNUpFihSxPH7++ec1duxYDRgwQJ6enlbLvXDhgn799Ver11RSUpKef/55Sff2+bhx43TkyBGVKFFCVatWlWT9+fHPffSw1+iHH36oOXPmaP78+Ro0aJAqVqyoDz/80Kp+WgwaNEgHDhzQoEGDNHToUKv1S1KnTp2s6tvZ2en8+fPKnz+/pSzlyxpnZ2dL2f2OIf75XpaUlPTA+kWLFtXx48d18+ZNJSQkpJpeokQJqwEmzPsurZ/5GYGQlI0UKFBAOXLk0IIFC+Tu7m4p/+uvv6zeKMw3+RUtWjTV6CYp87u6uqpt27ZWN6ZGRkYqZ86clsfmb0CTk5MVGRmpokWLPrCN5nUXL1481WhqERERVi+Wp0GJEiVSnY2IiIhQ4cKFVahQIeXMmVORkZEqU6aMpHvX7t7vuujo6GhdvnzZcu340aNH1bdvX82ePVuhoaEPXL+rq6uuX7+uu3fvWkLO3r17dejQIXXr1u2hbU/5dunq1at65513tGrVKhUpUkSurq56/vnntXnzZqv2RUVFqWDBgipevHiq501kZKQcHR0tj8197erqqpw5c2r37t2WD4n4+HhFRESoVKlSOn36tKpUqaK2bdsqNjZWmzdvVmhoqLy8vJSUlCQ/Pz9169ZNt2/f1pdffqmQkJBU96cVL178gf2Qne3cuVO9e/fWtm3blD9/ftnY2KhcuXLq16+ffv75Zx05ckS1a9dWkyZNNHHiRO3cuVM//PCDWrdu/cCD1Hbt2mnMmDGqU6eOcuXKpcqVK6fb6I7Z0fPPP68xY8Zo4MCBVl9obdq0SUuWLNGyZcssZ3DGjBmj48eP33c5nTp10quvvqrGjRvLxsZG9erVk3Tv9eTj42P1jfj169d1586dNLexQoUK6tixo+X9ZtKkSYqMjNTWrVuVO3duSVKrVq0s9R0dHdWqVStt2LBBxYoVU/PmzS0HVa6ururdu7fVfWvnzp1T/vz5//P7Wla3detWOTs7q0aNGjp+/PhD39+KFi2q7du3W82/atUqFSpUyKrsYe+DZsWLF9d3331nVXbu3Dk5OjqmW/D85/v5g44N8ufPn6bjkP/q1VdflaOjoxo0aKAePXooNDRUpUqVkpub230Ht/jn+1bz5s21e/du9e3bV25ubpaw4Orqqnbt2lkGsZDufYmc8iVBnz595Ofnp/nz58ve3l7Xr19PdZ/nP/fRw16jR44cUefOndWrVy9du3ZNM2fOVFBQ0CPfd+3o6KhPP/1U7du31+eff24pT9nXmzZtsvoMPHnypEqWLGn1ZXaxYsV07do1q2OIRx0513xGTbr32Vu8eHG5uLgoR44cioiIUNmyZS3Tz507Z3WPnXnfHTt27IGf+eYBhTICl9tlI7a2tgoICNDkyZN18eJFJScna82aNWrZsuUDb5ps166dvv/+e/3vf/9TcnKydu7cqenTpytPnjzq1KmTFi9ebLnB7uDBg2rfvr3VKdIVK1bo0KFDio+P18yZM2UYhuUmSkdHx4d++9yxY0fNnTtXhw8fVlJSkjZt2qStW7eqXbt2T3CvPDnXrl3TxYsXrf4SExMVEBCgr776Srt27VJSUpJ+/fVXffXVV+rQoYOlT6ZPn65Lly7p7t27mjBhgtU3MCnu3Lmj7t27a/369TIMQ88995xsbW0t3948aH9Wr15dpUuX1kcffaS7d+/q6tWrmjBhguWbzrQYM2aMnJycNHDgQEsfplwCEB8fr1u3bik0NFQhISGysbFRx44d9f3332vnzp1KSkrS9u3bU31o/7ONpUqV0sSJE3Xnzh3FxsZq/Pjx6tatm5KSkrRt2zYFBQXp/Pnzlg9ae3t75cmTRytWrNDAgQMVFRWl3LlzK3fu3HJ2drYKZNK9y4G2bt2qTZs2KSkpSUeOHNFnn31muSQou/L29lahQoU0ePBgHTt2TAkJCYqOjta6det05swZNWjQQNK9M7GvvPKKvv76a23ZssVqwIZ/8vX1VUJCgsaOHauAgIAM2pLsxd/fXx06dNBXX31lKbt9+7ZsbW2VM2dOGYahHTt2aO3atQ8cObBixYoqU6aMxo8fr3bt2lkOwFu1aqUDBw5o3bp1SkxM1OXLl9WzZ0/L5bJpcfHiRa1bt87yjXp0dLRy5MghOzs7xcXFacGCBTp+/LhV21IG1/n++++twl+nTp00a9Ysy83VO3fuVIsWLfTbb7/96/va0yY+Pl4bN27UlClTFBISoty5c//r+1uLFi105MgRrV27VklJSTp06JAmTpyY6gziw94HzVq0aKFTp05p0aJFio+P17lz5zRlyhS1atUq1ftienjYscF/OQ75r/r06SN3d3d98MEHqS43e5ghQ4YoX758VrcGBAQE6Ntvv7UcC505c0avv/66FixYIOneazdnzpyys7PTtWvXNHbsWEl64Gv3316js2fP1pgxYxQdHa28efPKycnJ8prIkSOH7t69q8TExDRtT6lSpTRmzBiry22LFCmiBg0aaNy4cbp+/boSEhI0a9YsBQQE6NatW1bz16hRQ+XKldPEiRN19+5dXbp0SWFhYWncm/f88ccfWrVqlRISErRt2zZt3bpVHTt2lK2trTp06KApU6bo7Nmzio+P16JFi3Ty5MkHDgaU1s/8jMCZpGwmNDRU06dP12uvvaYbN26oZMmSCgsLS3VpVApPT0999NFH+uijj3ThwgUVL15cU6ZMUfny5VW+fHnFxMRoyJAhioyMVP78+dWtWzer0cRq1aql0aNH6+TJk6pcubIWLFhgeUMPCAjQp59+qoMHD973sp633npLycnJCgkJ0ZUrV1SqVClNmTJFtWrVSp+d85iCg4NTlW3cuFHNmzdXdHS0xo4dq8jISBUpUkQDBw5U27ZtJUn9+vXTmDFj5O/vr1y5cqlz586ytbW1XO6VokiRIgoLC9PUqVM1fPhw5cyZU/7+/pazQW3bttXIkSN16NAhffzxx5b5HBwcNHv2bI0fP14NGjSQvb29WrVq9UjDwefKlUuTJk3Sa6+9pvnz5+vdd9/VwoULNXHiRM2bN0/Jycny8fGxXBdcrVo1jRo1SiNHjtT169ct98f9c5tS2Nvba86cOfroo4/UpEkTxcXFqXr16vr888+VI0cOvfHGG7p06ZJeeeUVRUdHq3jx4vr000/l6uqqvn37avTo0WrRooXi4uJUpkwZhYeHp7pHpkaNGpo2bZpmzpypIUOGqECBApbL9bKznDlz6ssvv9SMGTP0/vvvKyoqSg4ODnJ3d9fnn39u9e1d586dNWvWLHl5ealcuXIPXKa9vb1at26tpUuXqmXLlhmxGdnSkCFD9H//93+Wg5J27dpp3759atGihezs7FSmTBm9+eabWrp06QNHo+zUqZNGjBhhFVaLFy+uefPmadKkSRo7dqzs7OzUoEEDq8tt/mnv3r3y8PCwPHZycpKvr6/lbE5wcLAGDx6sOnXqyNnZWZ6enmrTpo3VWa6KFSvq+eefV0xMjNXlSt26dZNhGAoMDNTly5dVpEgRDR8+XI0aNZKkh76vPQ1GjBhhudQxR44cKlOmjEaNGiV/f39J//7+9vzzz2vu3LmaPHmyxowZo0KFCmnQoEF66aWXrO6redj7oFmJEiU0b948TZkyRdOnT1fOnDnVsmXL+35GpYdmzZo99NjgUY9D/itbW1tNnjxZ7du3V3BwsObPn//QS05TpFwSaw76NWrU0JQpUzRlyhT16dNHTk5OatmypeV34yZMmKDx48drwYIFypcvn/z9/VW5cmUdP35cL730Uqp1/NtrdPTo0Ro1apQaNWqk+Ph4Va1aVdOmTZP0/7/48vb21vLly9P0+3T+/v6WL2hTfPzxx5o8ebLatm2r6OholS9fXvPmzVPhwoWtLnWztbVVWFiYRowYodq1a8vV1VV+fn5Wo93+mzp16ujHH3/U2LFjVaJECU2bNs3S3wMHDtT06dPVrVs33bhxQ25ubpo/f75eeOGF+y4rrZ/5GcHGyIo3eeCp0LVrV9WqVUu9evXK7KZkab/99pvc3NyUN29eSfe+sfX09NSWLVus7ul6mpw+fVrJyclWB+C9evVSmTJl7nvDJ4DsISgoSNWrV3/s3wcCkDXExsZq//79qlWrliVkbt26VSNGjLD6WZZnEZfbAelswYIFGjdunGJjYxUXF6ewsDC98MILT21Aku5d1/zmm29a7gHavXu3du7cmerGZQDZQ0REhL7//nv98ssv9x04CMDTycHBQcHBwfr666+VnJysqKgoLViwIE2/P5XdcbkdkM5GjhypUaNGydfXV0lJSfL09NTcuXMzu1mPpXHjxjp58qTeeOMN3bx5U8WLF9eYMWOeil8zB/DoZsyYoR9//FFDhgyxGnUUwNPNzs5OM2fO1Mcff6xJkyYpR44catq0qQYMGJDZTct0XG4HAAAAACZcbgcAAAAAJoQkAAAAADAhJAEAAACACSEJAAAAAEwISQAAAABgQkgCAGRpbm5ucnNz019//ZVq2ueffy43NzdNnz79Py179+7dafpFe0lavXq1/Pz8/tN6AABPF0ISACDLK1CggNasWZOqfPXq1cqdO3cmtAgAkJ0RkgAAWV6rVq30zTffKDk52VL2xx9/KD4+XpUrV7aUJScna+7cuXr55Zfl6empgIAA7dy50zL98uXL6tmzp2rWrKlGjRrp559/tlrPuXPn1LNnT/n4+Khhw4b69NNPFR8fn/4bCADIUghJAIAsr0GDBkpISNAvv/xiKVu5cqUCAgKs6s2cOVNLly7VtGnTtHv3br399tsKDAzUH3/8IUkKCQmRvb29duzYoSVLlmjHjh2WeWNiYtStWzeVL19eO3bs0JdffqlffvnlP1/KBwB4ehGSAABZnr29vVq1amW55C42NlZbtmxR27ZtreqtWrVKPXr0UJUqVWRvby9/f3/5+flp5cqVunDhgvbu3av+/fsrd+7cKlq0qIKCgizz/vTTT4qPj1ffvn2VI0cOFS1aVH369NHSpUszclMBAFmAfWY3AACAtGjfvr06d+6s6Oho/fDDD6pZs6YKFy5sVefq1asqWbKkVVmJEiX0559/6tKlS5KkYsWKWaY9//zzlv8vXLiga9euydvb21JmGIYSEhIUFRWVHpsEAMiiCEkAgKdCxYoVVaZMGW3atEnr16/Xm2++mapO8eLFFRERYVUWERGh5557Tq6urpbHZcuWlSRdvHjRUs/V1VXPP/+8Nm/ebCmLjo5WVFSUChYsmB6bBADIorjcDgDw1Gjfvr0WLlyo06dPy9fXN9X0jh07au7cuTp8+LCSkpK0adMmbd26Ve3atVOxYsX00ksvacKECbp586auXLmiGTNmWOZt2LCh7ty5o3nz5ik+Pl63bt1SaGioQkJCZGNjk5GbCQDIZIQkAMBTo2XLljp79qxat24te/vUF0O89dZb6tKli0JCQuTl5aU5c+ZoypQpqlWrliRp8uTJypMnjxo2bKgOHTqoTp06lnlz586thQsXavfu3apfv75efvll2draatasWRm2fQCArMHGMAwjsxsBAAAAAFkFZ5IAAAAAwISQBAAAAAAmhCQAAAAAMCEkAQAAAIAJIQkAAAAATAhJAAAAAGBCSAIAAAAAE0ISAAAAAJgQkgAAAADAhJAEAAAAACaEJAAAAAAwISQBAAAAgMn/AynYBqgXM0ouAAAAAElFTkSuQmCC"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 16
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-08T06:06:16.132193Z",
     "start_time": "2025-06-08T06:06:15.942481Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 提取各模型的F1分数\n",
    "f1_scores = [\n",
    "    classification_report(y_test, y_pred_perceptron, output_dict=True)['1']['f1-score'],\n",
    "    classification_report(y_test, y_pred_logistic, output_dict=True)['1']['f1-score'],\n",
    "    classification_report(y_test, y_pred_svm, output_dict=True)['1']['f1-score'],\n",
    "    classification_report(y_test, y_pred_nb, output_dict=True)['1']['f1-score'],\n",
    "    classification_report(y_test, y_pred_dt, output_dict=True)['1']['f1-score'],\n",
    "    classification_report(y_test, y_pred_knn, output_dict=True)['1']['f1-score']\n",
    "]\n",
    "\n",
    "# 绘制F1分数柱状图\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.bar(models, f1_scores, color='lightblue')\n",
    "plt.xlabel('Model')\n",
    "plt.ylabel('F1 Score')\n",
    "plt.title('Model F1 Score Comparison')\n",
    "plt.ylim(0, 1)  # 限制y轴范围在0到1之间\n",
    "for i, v in enumerate(f1_scores):\n",
    "    plt.text(i, v + 0.01, str(round(v, 4)), ha='center')  # 在柱子上方显示F1分数值\n",
    "plt.show()"
   ],
   "id": "e47c3d2279e4df4e",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 17
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-08T06:06:16.323426Z",
     "start_time": "2025-06-08T06:06:16.138225Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 提取各模型的精确率\n",
    "precisions = [\n",
    "    classification_report(y_test, y_pred_perceptron, output_dict=True)['1']['precision'],\n",
    "    classification_report(y_test, y_pred_logistic, output_dict=True)['1']['precision'],\n",
    "    classification_report(y_test, y_pred_svm, output_dict=True)['1']['precision'],\n",
    "    classification_report(y_test, y_pred_nb, output_dict=True)['1']['precision'],\n",
    "    classification_report(y_test, y_pred_dt, output_dict=True)['1']['precision'],\n",
    "    classification_report(y_test, y_pred_knn, output_dict=True)['1']['precision']\n",
    "]\n",
    "\n",
    "# 绘制精确率柱状图\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.bar(models, precisions, color='lightgreen')\n",
    "plt.xlabel('Model')\n",
    "plt.ylabel('Precision')\n",
    "plt.title('Model Precision Comparison')\n",
    "plt.ylim(0, 1)  # 限制y轴范围在0到1之间\n",
    "for i, v in enumerate(precisions):\n",
    "    plt.text(i, v + 0.01, str(round(v, 4)), ha='center')  # 在柱子上方显示精确率值\n",
    "plt.show()"
   ],
   "id": "16a3ba803fb155f8",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 18
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-08T06:07:07.093426Z",
     "start_time": "2025-06-08T06:06:16.343023Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import roc_curve, auc\n",
    "\n",
    "# 获取各模型的ROC曲线数据\n",
    "y_pred_perceptron_prob = best_perceptron.decision_function(X_test_vec)\n",
    "y_pred_logistic_prob = best_logistic.predict_proba(X_test_vec)[:, 1]\n",
    "y_pred_svm_prob = best_svm.decision_function(X_test_vec_reduced)\n",
    "y_pred_nb_prob = best_nb.predict_proba(X_test_vec)[:, 1]\n",
    "y_pred_dt_prob = best_dt.predict_proba(X_test_vec)[:, 1]\n",
    "y_pred_knn_prob = best_knn.predict_proba(X_test_vec)[:, 1]\n",
    "\n",
    "# 计算各模型的ROC曲线\n",
    "fpr_perceptron, tpr_perceptron, _ = roc_curve(y_test, y_pred_perceptron_prob)\n",
    "fpr_logistic, tpr_logistic, _ = roc_curve(y_test, y_pred_logistic_prob)\n",
    "fpr_svm, tpr_svm, _ = roc_curve(y_test, y_pred_svm_prob)\n",
    "fpr_nb, tpr_nb, _ = roc_curve(y_test, y_pred_nb_prob)\n",
    "fpr_dt, tpr_dt, _ = roc_curve(y_test, y_pred_dt_prob)\n",
    "fpr_knn, tpr_knn, _ = roc_curve(y_test, y_pred_knn_prob)\n",
    "\n",
    "# 计算各模型的AUC值\n",
    "roc_auc_perceptron = auc(fpr_perceptron, tpr_perceptron)\n",
    "roc_auc_logistic = auc(fpr_logistic, tpr_logistic)\n",
    "roc_auc_svm = auc(fpr_svm, tpr_svm)\n",
    "roc_auc_nb = auc(fpr_nb, tpr_nb)\n",
    "roc_auc_dt = auc(fpr_dt, tpr_dt)\n",
    "roc_auc_knn = auc(fpr_knn, tpr_knn)\n",
    "\n",
    "# 绘制多模型ROC曲线对比图\n",
    "plt.figure(figsize=(10, 8))\n",
    "plt.plot(fpr_perceptron, tpr_perceptron, label=f'Perceptron (AUC = {roc_auc_perceptron:.4f})', color='blue')\n",
    "plt.plot(fpr_logistic, tpr_logistic, label=f'Logistic Regression (AUC = {roc_auc_logistic:.4f})', color='orange')\n",
    "plt.plot(fpr_svm, tpr_svm, label=f'SVM (AUC = {roc_auc_svm:.4f})', color='green')\n",
    "plt.plot(fpr_nb, tpr_nb, label=f'Naive Bayes (AUC = {roc_auc_nb:.4f})', color='red')\n",
    "plt.plot(fpr_dt, tpr_dt, label=f'Decision Tree (AUC = {roc_auc_dt:.4f})', color='purple')\n",
    "plt.plot(fpr_knn, tpr_knn, label=f'K-Nearest Neighbors (AUC = {roc_auc_knn:.4f})', color='brown')\n",
    "plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n",
    "plt.xlim([0.0, 1.0])\n",
    "plt.ylim([0.0, 1.05])\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.title('ROC Curve Comparison')\n",
    "plt.legend(loc=\"lower right\")\n",
    "plt.show()"
   ],
   "id": "1a2a37ed8407d155",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x800 with 1 Axes>"
      ],
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1MAAAK3CAYAAABgGhW8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3hT1RvA8W9W996lQBllrwKyl4DIXjIEFbc4cCtuxb1Qf+IAxYngQIYKgogCIkv23pRVoHvvNsn9/ZGSNCQtbUlJx/t5Hp6ee+65N29o2ubNWSpFURSEEEIIIYQQQlSI2tkBCCGEEEIIIURNJMmUEEIIIYQQQlSCJFNCCCGEEEIIUQmSTAkhhBBCCCFEJUgyJYQQQgghhBCVIMmUEEIIIYQQQlSCJFNCCCGEEEIIUQmSTAkhhBBCCCFEJUgyJYQQQgghhBCVoHV2AEIIIWDKlCls27bNqk6lUuHp6UmTJk24/fbbGT58uM11O3fu5Ntvv2XXrl1kZmYSEhJCjx49uOOOO2jatKndx9qyZQvff/89e/fuJTMzk7CwMPr378/dd99NUFDQZWM1Go0sWbKEX3/9lRMnTlBUVERkZCRjx45l0qRJuLi4VO4/4Srbv38/3333Hdu3byc1NZXg4GB69OjBvffeS4MGDZwdnkMsXbqUZ599ljVr1lC/fn1nhyOEELWOSlEUxdlBCCFEXTdlyhSys7OZMWOGuc5gMBAfH8+3337Lvn37+OKLL+jbt6/5/Ny5c/nggw/o1asXY8eOJSQkhDNnzvDjjz9y4sQJ3nrrLZsE7P333+eLL75gyJAhDBkyBD8/P44dO8YXX3yBTqdj/vz5RERElBpnXl4e9913H3v37mXy5Ml07doVnU7H1q1bmTdvHl26dGHOnDnVPqH6/vvvefPNN+nWrZv5/+7s2bN8+eWXpKWl8c0339CmTRtnh3nFUlNTOXv2LK1bt6723xMhhKiRFCGEEE53yy23KLfccovdc1lZWUrbtm2Vhx9+2Fy3du1apXnz5sqHH35o076wsFB56KGHlLZt2yrHjh0z169YsUJp3ry58s0339hcc+bMGaVjx47KvffeW2acL774otK2bVtl9+7dNudWrlypNG/eXPn666/LvIez7dixQ2nVqpXy+uuv25xLSUlR+vXrp4wcOdIJkQkhhKhpZM6UEEJUcy4uLuh0Oqu6Tz75hMaNG/Pwww/btNfpdLzyyitoNBq++OILc/3nn39OVFQUt912m801DRs25KmnnqJz584YjUa7caSmprJkyRLGjRtHdHS0zfmhQ4dy1113ERYWBsC5c+do0aIFS5cutWr3zDPPMGDAAPPxlClTePLJJ3n44Yfp1KkTU6dOZfDgwUybNs3mMSZMmMDUqVPNx3///Tc33HAD7dq1o1evXrz++uvk5ubajf+ir776Cm9vbx5//HGbcwEBATzzzDNcf/31ZGdnm+tXrlzJDTfcQMeOHenVqxcvvfQSGRkZ5vMff/wxQ4YM4e+//2bEiBG0a9eO0aNHs3v3bvbs2cOECRNo3749I0aMYMuWLVbXDRgwgHXr1jFkyBA6dOjAhAkTrNoAHDlyhAcffJDu3bvTpk0b+vTpw+uvv05+fr65TYsWLfjkk08YN24cnTt3Zvbs2SxdupQWLVpw7tw5wPQ9fPLJJ+nVq5c5xl9//dXqsU6fPs3DDz9Mr169iI6OZsqUKezcudN8/uL39Y8//uDhhx+mY8eOdOnSheeff56cnJwy/++FEKK2kWRKCCGqCUVR0Ov15n8FBQWcOXOGF154gZycHEaPHg2Y3hAfOHCA/v37o1Kp7N7L39+fnj17smbNGgCSkpI4cuQI1157banXTJo0iXvuuQe12v6fhi1btqDX6+nfv3+pz+Gpp55i6NChFXnaAPzxxx/odDo+/fRTbr31VkaPHs2///5rldCcPXuWffv2mf8fli9fzrRp02jSpAmffvopDz74IMuWLeOBBx5AKWUEu6IobNy4kR49euDu7m63zZAhQ3jwwQfx8vICYPbs2Tz22GN06NCBjz76iGnTpvHnn38yZcoUq2QmPj6et956i/vuu48PP/yQjIwMHn74YR5//HEmTpzIBx98gNFo5LHHHrO6LjU1laeffpqbbrqJWbNm4e7uzj333MOBAwcASExM5OabbyYvL4+3336bL774gqFDhzJ//ny+/fZbq9jnzJnD4MGD+eCDDxg4cKDNc5s+fTonTpzglVdeYe7cubRu3Zqnn36arVu3AnDixAluuOEGYmNjeeGFF3jvvfdQqVTcdtttNnP6ZsyYQUREBLNnz+buu+9myZIlfPbZZ3b/T4UQoraSBSiEEKKa2L59u808HZVKRfPmzZk1a5a5N+f8+fMAl11QIDIykjVr1pCRkUF8fHy5rimLI+5RGrVazWuvvYaHhwcAjRo14qOPPuKvv/5i7NixgCl58vT0ZODAgSiKwnvvvUefPn147733zPdp1KgRt99+O+vXr+faa6+1eZy0tDQKCgrK/RwyMjKYM2cOEyZMsJrP1rx5c26++WaWLl3KTTfdBJjmk82YMcM8ry0mJob333+fN954g/HjxwOmeXAPP/wwp06dolWrVubrXn75ZcaMGQNA9+7due6665g7dy4fffQRx44do1WrVsyaNcuc4PXs2ZMtW7awfft27rvvPnNc7du3t+q5O3jwoNXz2bZtGw888ADXXXcdAN26dcPPzw+NRgOYejx1Oh3fffcd3t7eAFx77bWMGDGCmTNnsmjRIvO9+vXrx9NPPw1Ajx492LRpE//88w9PPPFEuf5vhRCiNpCeKSGEqCbatGnD4sWLWbx4MZ9++inNmzenUaNG/O9//2PIkCHmdhd7XS4d+nepi2+QFUUx9zaVNoSvPBxxj9LUr1/fnEhdPO7cuTMrVqww161YsYLBgwfj5ubGyZMniY+PZ8CAAVa9eV26dMHLy4tNmzaV+RwMBkO54tqzZw+FhYWMHDnSqv6aa64hIiLC3KNzUadOnczliysjlhwS6efnB0BmZqa5TqPRWC0U4ubmRt++fc1D63r37s2CBQtwdXXl1KlTrFu3js8++4zU1FQKCwutHr958+ZlPp9u3brx8ccf88gjj7B06VJzr9g111wDmJKt/v37mxMpAK1Wy/Dhw9m/f7/VML5Lh3qGhYVddoilEELUNpJMCSFENeHp6Um7du1o164d1113Hd9++y3Z2dnceeedpKammttdXG3vYg9VaWJjY/Hw8MDPz4/w8HBUKlWZ12RmZpY55+Xi4164cKHUNklJSej1+jLjssfekuxjxoxhy5YtpKWlcfjwYWJiYsxD/NLT0wF45ZVXaNOmjdW/7OxsEhMT7T6On58fnp6eZT6H3Nxc8/0vzouyF19QUBBZWVlWdRd7jkpyc3Mr9bHANE/r0sQ4MDDQ/NhGo5H33nuPrl27MmTIEF555RUOHTqEq6ur3ZjK8r///Y877riD/fv38+yzz9KnTx/uuusuYmNjAdPzLe25KopiNezy0mGSarW61OGVQghRW0kyJYQQ1VRgYCAvvfQS8fHxvPHGG1b10dHRrF69utQ3r9nZ2WzatMk8byYgIIA2bdqwYcOGUq+ZM2cO3bp1Iy4uzu757t27o9PpWL9+fakx33vvveZenItzsy7tBSpv78WQIUPQaDT89ddf/P7774SHh9O1a1cAfHx8ANMcrYu9eSX/lTXUrHfv3mzdupWCggK755cuXUqPHj3YvXs3vr6+ACQnJ9u0S0pKwt/fv1zPpSzp6ek235Pk5GQCAwMB0xL43377Lc8//zw7duzgn3/+4aOPPiIgIKDCj+Xt7c306dNZu3Ytf/zxB48//ji7du3ilVdeAcDX17fU5wo45PkKIURtIsmUEEJUY9dffz19+vTh999/txpS9uCDD3Ly5Ek+/PBDm2sMBgMzZswgPz+fu+++21x/1113cezYMebPn29zzcmTJ1m0aBFdu3YlPDzcbiw+Pj6MHz+en3/+mX379tmc//333zl48KC59+hiL83FuVYARUVFdq+1x9vbm/79+7NmzRpWrVrFyJEjzcP0mjRpQmBgIOfOnTP35rVr146wsDDef/99Dh06VOp977zzTtLT0/nf//5ncy4lJYUvv/ySyMhIoqOj6dChAy4uLixfvtyq3Y4dO7hw4YLVsL7KKioqYsOGDebj/Px8/v33X3r06AGYNmaOiopi/Pjx5uF3CQkJHDt2rEJDLs+fP0+/fv1YtWoVYPo/vOeee+jZs6f5e9SlSxfWrVtn1eNmMBhYsWIF7dq1k72qhBDiErIAhRBCVHPPPfcco0aN4vXXX+eXX35Bq9XSp08fnnnmGd59910OHTpk3nj23Llz/Pjjjxw+fJg33niDli1bmu8zbNgwNm/ezBtvvMHevXsZMmQInp6e7N+/n6+//hofHx/eeuutMmN5/PHH2b9/P7fddhs333wz3bp1Q6/Xs2HDBn7++Wf69u1rTuB8fX3p2LEjCxYsIDIyEn9/f+bPn09+fr7V/KiyjBkzhmnTpmEwGBg1apS5XqPR8Nhjj/HSSy+h0Wjo378/mZmZzJ49m4SEhDI33I2OjuaRRx7hww8/JCYmhrFjx+Lv78/x48f5+uuvycnJYe7cuahUKvz8/Jg6dap5YYaBAwdy7tw5Zs2aRVRUFDfccEO5nsflPPfcczz66KMEBgby1VdfkZuby/333w+YFpWYPXs2c+fOJTo6mjNnzvD5559TWFhIXl5euR8jIiKCsLAwXn/9dbKzs2nYsCEHDhxg/fr13HvvvYApSf/333+59dZbmTp1Ki4uLixYsIDY2Fi+/PJLhzxXIYSoTSSZEkKIaq5JkyZMmTKFr7/+mgULFnD77bcDcMcdd9CxY0fmzZvHO++8Q2pqKsHBwfTq1Ys33niDqKgom3u9/vrrdOvWjZ9//pkZM2aQnZ1NREQE48aN4+67777s0DEfHx/mz5/PggULWLlyJT/99BOKohAZGcmzzz7LhAkT0Gotf1refvttXnvtNV588UW8vLwYP348HTt2tFoVrix9+vTB19eXsLAwmjVrZnVuwoQJeHp68uWXX7Jw4UI8PDzo1KkT7733Hg0aNCjzvvfffz+tW7fm+++/56233iI9PZ2wsDD69u3LfffdR7169cxtH3roIYKCgliwYAGLFi3Cz8+PIUOG8Oijj5a6vHpFvfzyy7z55pukpqbSqVMnfvzxRyIjIwHT0Mm0tDS+++47Pv30U8LDwxk9ejQqlYrPP/+cjIwM83DEy/nkk0/44IMPmDVrFmlpaYSHh/Pggw+aVwBs1qwZP/zwAx988AHPPfccKpWK9u3b891335kXqRBCCGGhUmS2qBBCCOEUH3/8MZ988glHjx51dihCCCEqQeZMCSGEEEIIIUQlSDIlhBBCCCGEEJUgw/yEEEIIIYQQohKkZ0oIIYQQQgghKkGSKSGEEEIIIYSoBEmmhBBCCCGEEKISav0+U0ajEb1ej1qtRqVSOTscIYQQQgghhJMoioLRaESr1aJWX3m/Uq1PpvR6Pfv373d2GEIIIYQQQohqol27dri4uFzxfWp9MnUx42zdurVD/sOEKI3BYGD//v20a9cOjUbj7HBELSavNXG1yGtNXC3yWhNXS2FhIYcOHXJIrxTUgWTq4tA+jUYjP5ziqpDXmrha5LUmrhZ5rYmrRV5roqpdfH05avqPLEAhhBBCCCGEEJUgyZQQQgghhBBCVIIkU0IIIYQQQghRCZJMCSGEEEIIIUQlSDIlhBBCCCGEEJUgyZQQQgghhBBCVIIkU0IIIYQQQghRCZJMCSGEEEIIIUQlSDIlhBBCCCGEEJUgyZQQQgghhBBCVIIkU0IIIYQQQghRCZJMCSGEEEIIIUQlSDIlhBBCCCGEEJUgyZQQQgghhBBCVIIkU0IIIYQQQghRCZJMCSGEEEIIIUQlSDIlhBBCCCGEEJUgyZQQQgghhBBCVIIkU0IIIYQQQghRCZJMCSGEEEIIIUQlSDIlhBBCCCGEEJUgyZQQQgghhBBCVIJTk6nU1FQGDRrE1q1bS22zfv16Ro4cSXR0NEOHDmXdunVXMUIhhBBCCCGEsM9pydTOnTu58cYbOXv2bKltTp8+zUMPPcQjjzzCjh07eOihh3j00UdJSEi4ipEKIYQQQgghhC2nJFO//PILTz75JI899thl211zzTVcd911aLVahg0bRpcuXVi4cOFVilQIIYQQQghRGyiK4vB7ah1+x3Lo3bs3I0eORKvVlplQnThxgubNm1vVRUVFceTIkQo/psFgwGAwVPg6Icrr4utLXmeiqslrTVwt8lqrxowGMOSW3aYoHYoySz+fdwEUfXE5HwzGUpvqjUbyC7LR7PoeilIwuoRjNKqs2hQUmcIChZzMjaRrG5CVexSDKsCq3fkiPRoVpuuLb3G0sBBPFby7oIgGWh0oEJxqxKACo2JuRlC6wvHCIoK1GvIxcsFgJEBdet+AitKfU0W0iYN0dyyBOEBQFkRkQJJX6W2MQK7i0IcFwD8PouMhxvpbg2L+qqJXrIpz3ioKNaZjRaVCgeKvlmNQEZqjQq9SYVRZzl8sG1UqjKhQVGA0nzMdlywbL72u+DGMVu0sxxfvrYDlHJbHvHgPg0qNQaXGiIozBb4UuXox/Ps3HfZ/6ZRkKjg4uFztcnJycHd3t6pzc3MjN/cyvzzsOHToUIWvEaIy9u/f7+wQRB0hrzVxtZTntaYxZKI2Vvzvc3m46BNBufyb4oxcPUfO52EwWL/1NBpU7NvnhZ9fEQCeOZlo9Xp8s1JBAc/cLFwKCzBe8qa8UFVAEYVWdQ3jzpPt4Ul+gQa9HgI9k6ifnEC+xg10Bty0ORQZ3AAFX9dk8vT23yl7u6RRZHTBqGhMMemyMCoq8/FFBgWyFAVtiaekQkGtKn+S4HcUdHrwygRdEeS4g17BnGb451/+HhrA1aqmPL9/jhZ/TS13rCb6CrZxTMJUllytFgVIdXdHr1JdNrlJc3PDpZwfQvin29ZZEofSkwVjieTGaDeRwOYeF88VAP+F27ZVVJZntqhlucIH4ED53to7mUKkRzo7CoMcelenJFPl5e7uTn6+9U94fn4+np6eFb5X69atcXFxcVRoQtgwGAzs37+fdu3aodFoLn+BEJUkr7VqrDADEtaAWndFt1EVpkJBEmg8Sm+UeQTUWlRJm1C8m9m/T9xK8G1b6i0SiwqJS9xBpi6EZIMBbfFbxP35RfgZMioV+9Z8qFfi3cWuAvBRw6V/gdflQSOd6U26MRfi08HbOm9BpUDjdDCqoF0CZLpC1/MQmQFtEuFwsOWT9Itui61U2FUor4xzlyYNip06x/MsK6RyyNNCVoXeUqlQXTKzRMGAWtGhKHAxhzViQKPoUFBQo8G9sBAVcDAkBIBCVy16lYrAjGzOhfih0biBYkSt0qBGQ45iRFf8Gs7GiGtxWcHU43E5GejRokJv86oSqNWoLv7TqFGpSpSL69FqQacrrteg0qhBrSluozG10WiszpvbXKyzamOqo8Q503k1hZlGcpP05CYUkRNfSE5cEYUZBhRFbfpeK2oURYXeqMLV1wXfhh54RXrh28ST8W1DHPpfU62TqebNm3Pw4EGruhMnTtC2bel/GEqj0WjkTYe4KuS1Jq6WOvlaM5bzjWZhGuizyjifXjz8SQVZx0FT4jP3wgw49S2k7gTf1uZqg6JYv8XKOEyBAgkUJzx2hlylGyDBAGf18EcOeKvBw857uiQDHC2Chpf5q/xPHkRoIabIdB/L29OdZVy12W5tttWTSbQ+qYCLAbqchzFHoH0CnPYDxU7szVLAswhSiweSNLnk/NsnTF9Le/N9aQJVEb0clDgdC4TmKbC1PuRckgcbAfcSn9ZrFAjPUNjWyFKnRiEiVc2Ohlr0GgVQoSgawDQ+69LepotUKBixPqcotkPWCslDgw5PlX+JhqA3anBxsfNNUUBlek/KxQFiurR48iPbEe/rzoUwhYjg1ugNRTTwakJD7yg8fMMp8vEr9f9IpVIR6h6BotVhLCogL+YwHvln0bpafnZUatBqIGnnTtRqDRq17fNO2b8fFx8f1C4uKEYj8Zs349u0KYqikHnyJFoP08+TobAQRW//5/2su5f5eYIaFPtJaG4lkqLLJVIqrRZFrye0WzdQlZGgKQpZZ88S1r17hWMAUGu1pgRCq0Wt1aIuUVZpNJavOp3p3MW6S9sUX2tzTqNBVXxtyXuZz11sq9WakpiynmsVMhQZSDqURPyeeOJ3x5u+7omnIKMA0BX/s3zoFNAsgLDoMMI6hkF9H578aCvDRjRn+oxrzW0KCwsdOrKjWidTo0aN4ptvvmHlypVcf/31rF69mm3btvH88887OzQhhBCX0uea/pWmIBmyjkLaHsg5DTp/07svQy4kbwXvppCwFjwbgarknycFUrZVKJRco2mewaY8OFpoSmYA3CrwfmBrPvicP8Q/eaZ7lfFoFYqtLIfKkVjEFBU/aikx+eRD4zRok2T6mukKagV6xsJZX1Ob/qfhpL/pvWivWEjyUBOebSQ0BxLctYTmOb53pLxJU6ZXCNoS335NUQGuORlkRbXBJS2JzFad8ChMxxAcQkGLVhS0sIxFUqshPMAHlbc3dOhQ+ptdDw8oMcrl4uzsbhV4PpF26ir3ttk59Hl56ItH/xjy8ihISyN5714ubNyIT+PGVm2zz57l3Nq1l6bcDpMRE2OJq4ypHCq1GsVoJLBdOzzCw20bGI3kxMcT0rkziqKQn5JCYLt2FYpF4+JCQJs2uAUEoHFzM9drPTzQljgWjleQVUDC3gTi98QTtzuO+N3xJB1MwlBoO1xS46IhpG0IodGhhHcMJ6xjGKHtQ3H1NiX3f/xxnClTfiElJY/tO+Po2bMBgwY1rZK4q10y1bFjR1555RVGjRpF06ZN+fTTT3nvvfd4/vnniYiI4OOPP6bxJT/kQgghrpCimHpzUneAqvjT5MT1pnLyluJEKQtci8eax/8NGjfM06INFR83pChQWDIhSNlFvAEupKeQq5iShmQDpBpMPTol/Z4DaUZorIW/80xJUr4C7irIc8IIHVVR8SejRoXG6abkxUyXB/k+UOBNPfV5tHsng96Vxvlp5gnXAGgKQO+OVu9nc//QogwC9dlkadxAXYQqLwiMOlRFngzNX0vnov1cUIVQTyn/293OcZZyRJZlzklpiVR8y2uJaz3QfFxYCEFBpgRGm5VGflgjNAG+eBV3Gri4YC6rsjLRXD8QXF3t3Bnw9wdvb9Bq8SklXu/irzViakYFGQ0GErdtMyd/madOoXFzIzc+Hn1uLtpL5o+DaVWyk0uXUpCejkdYmM35rNOnUbu4mIZFXcKQX/YkqQvr15c7dr8WLXAPsp2Dkn3uHI1GjrTbo5GfkoJ/q1amIVxGIyqtFrfgYE4cP07L6Gjc/fzMbd1DQkw9JmUsMiFqnuz4bFPCVKLHKfVEqu24XcDV19XU21Tc4xTeMZyglkFoXGx7PvV6IzNmrOPNNzea6xo29MXPr+oSYacnU0ePHrU63r17t9Vxnz596NOnz9UMSQghqreibAIy/0B1ZC2UHEZzYYUp6XG384lt3gXIPgmedj5PT91RuTgMljdkOUY4VmhKcOL04Fri/VO6Ec7pTfNmZqWbelTUioZE45WvEHexlya/+A9waYmU/8H+uOjSIaEDFHrgohipV5CNERX1C7LQKEZzUtMkLx0AvUoNbun4pwYRlZdKgrEe12cc5ai6Ga4X/y4rMCD3b877tyKo8AK+OXF2Hx8yi/8B/HhlT7oUpSZSHTtCixZQVASpqdCli6k+Ph66djWV09KgXTvQ66F+fVMmFByMwc+PPUePEh0dTZhGg+1bdlGSoigk791LzoULqEsMwS3KzSXn3Dl03qaU8Mi335KXlIRrgGkptYLUii7QYC3r9Gm79cbCio2hdAsMJD8lBd+mTanXr5/VuYL0dHQeHjQYNAjfqChcfH0dOvTLYDBwQacjoHXrujd8uRZTjAqpMamWIXrFX7Pjs+22947wJrxjuFWPk18jv3K91uLispg8eQnr158x140c2Zx588bg72/7gYSjOD2ZEkKIWkmfB/lxUJQNuWdBVcaCBFnHTL08+hzTogL6HMg7b5rLc7HHqMR8HA3QGKC09+1lKUi6bJN4PaxMieSksYBQXTrbT3WjyOMcF7ID2O0Zg2duGBkecRRq8jBoy7EMmF3lSKQS2kHofoiLhvTGRCR58XTMbjJ0LhhRgWciXc+4E5WbTrzWj0KjJwPydxOjbgioURXPRWlijAHWFd90dykPVh6meUmtDccgx/pM0zQ7c5Z8fW3r9HrIyTElLgD798Pw4eV7+AsXoGFDqFfP9tz+/XD99dCnDzRpAg0alD2fo7zqyJLoJefnFOXmknH8OMbi5372zz9xDw4mfvNmUvbvt0yCt8NYyhyf0thLovyaN0cxGsk8dYrw3r3JjYvDp3FjXEv01lykKAq5CQk0GT0aNzu9QxpXV9wCAmzqAdQ6nc01zpoXI2oHfYGepINJVsP0EvYmUJhtJ6lXQVCLIMI6WnqcwqLD8Ayu+CJzAGvXnmLy5CUkJpp+OWs0Kt555zoef7xHlb+uJZkSQgh78uLg+Geg9aTUHT6SNlj39KQfgNTtpmToKjmUezM5OaYhV4oC9dx3sj1+PKl5ERw5AoFBpvfgRgwoXgkc0MVzPGQ7GoMLhS6ZuBSa3vAnhm+95M6WT/bwKx7yE2Ca15DlWo5P0VOiILtED5lnIl6aALJjG+PXbgtN0u+mQ0QrGrm3w1ttWlkpIwN6+p4l7Oh/eJ85SMNVn6MpgELvs7hk7Snz4aIKLb0yTY1nS29Y8k2w0WgaXubrC6dPmxKRiw4ehIEDTT00F4Nzd4emTU29ONHR1vfNy7P0/vToASGOXS1KOM7JX34hfutWXLy9yT5/vkJD2gAUoxHFePmluP1bt7YanleYkYHG1RWfxo1NPVh79tDmnnsIio4GRcEzIgJdJVYrFsIZ8jPyzYtBxO82/Us6lIRRb/uzoXXTEtIuxJwwhXcMJ6RdCC6eV77KtsFg5I03NvDyy/9wcT/eiAhvFi4cT69eDa/4/uUhyZQQou5QFOsV3ox6Uw9QXpypvOsxyI4BpQo+jdd6gXeUTbVRgbwcBaVgP7Hq6zmWmEJRIWQa/Pj3jAsxeiP6nGBScvxJCd5LtjYbVXokBfoS4799zoHvWcisj2lGSfGbwzDAPwaaXqh02F6EEabviqcX5LueoVVQG3xcfOke1o98Qx4NXOvhZdAS4RVJoHvxbBZFwT/9FO4Jp03JSFERHDliSlpaAkpv+HcRzHrelMAcPgzJyaXG4JJlJ3mbNs3S83L6NLRqZRrOplabkqRGjazbh4SYEiFR6+WnpLDrvffwCAnBUFjI0e++wzUgoFJD6fxbtkRRFNKPHqX5TTeRefo0DQYNIuKSIXAlufr7o5GtWEQtoSgKWReybIbppZ1Ms9vezd/NZpheUIsg1NqqmfNWWGhgyZLD5kRq8OCmzJ8/luBK9nBVhiRTQoiazZAP+QmQthcKU22H0xnzYe9zkH8F61A1vhX7vVOKaS5SUA9LVX4iuNeDBmPJ0bQgLkHH97+ksCr/ZbyUCHYdSkMbdoRk7T6M6hxQGcHj4pu8Vda3tzP1CYB6pcxx8j9V7qfUzD+KIVFD6Lsvg3ppejzjU9FrVEQvXI++V3dcdSXGlxsLYVVxbF4xxb0730Nmpt17V8iGDaWfa9nSNKTtpZcgNNS0QEFExJU/pqgRFMV2AlzKvn1knDyJWmf6OU8/coQL//4LKhUZJ06Uei97iVTDIUPwadQIfV4eIddcQ1gPy8+xvQUfhKjtjAYjqcdTbRaGyE2yv8Kib0Nfq2F64R3D8Wngc1WHi7q761i0aALdun3Jk0/24Nln+6BWX93hqpJMCSGqH0WBonTTV8UIubGmXoj8RNj9FKTvdezjadxNq9EFdDYN1ev2hSlB8mpq7v3IyM/AUNxjFZ8dT6HBNAY8MS2HdWfWYMgOYO06SNXGY8jL4Ozp+dB6Efiftn6sVuWIJ98HV40bBbpENIoLgR7B9G7UjSJDEXEZ5+nt0xbPAk/Cw8PxSstBU6gntyiXIFc/6iUXYNTp8Dobj1GrBpUaQ0EejWJSCNi8G1XixaTyBPCJ/f+Ov9bZrQcg2/6k4VKFhJjm+WRnm+YKXVz8wGCAQ4dg2DBT71R+PjRvbkqgvL3LvqeocQyFhWSdPYtSVETy3r0YiopQ9HrO/vknLr6+5oUZUooXb3CUFlOmYCwqQp+bS9SECWjd3fFq0ADdxWUGhaij9Pl6EvYnWA3TS9iXQFFukU1blUZFUMsg6x6n6DDcA67+hw5Go0Jqah5BQZa9pZo3DyQm5mECnBAPSDIlhHCG3HOmxRWyjsO2e8GjYfHcpGKZhyt/78DuoLvkzbg+B5I3Q4/5EDEcNKZfwucyz9FiTnuiw6JJzEkk6ewJwr2awIq3KNIbick4iqvKkwKlnHOgSk6TKaUDpVnWXeg1WYQG6fAw1KNjg3CGBPnQUu9B6OkUNOkZqJUsOHzcNBFq1SrwyoHww5CbC2fOALsq/N9yWdHR4Odn6gm6cAFuvdX6vKKYEstmzUy9RBdptfYXRNBosNosSNRaitGIYjBg1OtJ3rsXlUpF8t69FOXkcOjLL6vkMQPatMGleIGPjOPH8W7UiPBevfAIDcWnceMK7y0kRG2Wl5pnNb8pbnccyUeSUQy2vb86Dx2h7UOtepxC2oagcy9jEaWrJCUll9tu+5Vz5zLZsuUu3EvE5KxECiSZEkJUpdzzcOYnOPQOhPSF2CWltCtjwQAzlWnJ77ziT61bPQmh14FHBPi2MfcgxWfHM2f7HPzd/dkZt5MDiQc4n3me+j4d0a35mJz8mRxM2Wd1582xm83ljIIMq3NlJlKZxUmET3FMBycA4N/sKM21A/HzU9O0RT6PdHuYZgHNTEMf8vJMK6/98APMmlmO5w2kp5v+leViQpOUZNrLp21b2LMHRoww/d8UFJh6hzp0MC2QEBVlWgLb3d2yGZAQpSjKyeHYkiVknTmD1sMDfW4uJxYtqtS93ENCyEtMpP5112EsKiIvIYH6Awfi4mPaYaogI4OA1q3xDA/HvWTijmlDVVmkQQj7FEUhMzbTepje7ngyzmbYbe8R5GFKmkosDBHQLAC1pvrt6bV16zkmTlzM2eLn8sgjq5g7d6STozKRZEoIcWUUxbSqXfZJ07ylox+CVxRkXzJ/wV4i5dvatPiDfzS0fREo8QvcM5I8XRB6o54TaSdJzE0iNjOW9WfW8+eJP8k78xnZhe+hU+tQq0zXFRgKSg0zKfcyS4Iv/8z0NbMBFBa/WVMpNArz4/QRXwb28kNd5MP2HfDO2yr6X6tGqwUfH/DT5aCa9y3qIRc/GRti+nLgAOxMh2fGm4a7rVlTdgxgmo/UsqVpZbisLOjc2ZQcde8OHh5gNGJo04Y9p08THR2NRqu1XqFOiEoyFBaSn5zMmT/+YM8HHxDatSsKkLhtG0cve7U136ZNyYiJocF116HW6Wgydiyh3bqhlt5KIRzCqDeSfDTZZmGIvFT7G6j7NfYzLwhxscfJu553tV8OX1EUPvpoK9On/0VRkWmlwKAgD8aNK8+Y+atDfqsJIUpn1Fv2JSpIhtTdkLINzv0Cah3knLF/3aWJlGuwaVGGqKmm+0QMB/9OVvvgxKTG8PnOz0nISeC7vd+VO8Qio+347osaZ0/mVMYJSGwDqc1M+xahApUBF6M/hQmNeeSOBpw7Bzc8Dv37mzpqLvLxsZOnZGXB229D8zdNvT9gSpoqa+5cuOOOig2JMxggNtY0lE4SKVEBRoOBuE2bWH///aBSmfcuKkizXZkrYds2u/eIHDoUz3r1MBQUUJiZSdPx4/Ft2hSVWo3Oy6vUPZiEEJVTlFtEwr4Eq/2bEvcnos+33ddMrVUT3DrYqscprEMYbn5udu5cvWVk5HPnnctYutQy9L9Xrwb89NN46tf3cWJk1iSZEqKuyE82DZHLOQWZx0xfXfxNyU32SXALh9PzwaOBacGHyvKoD8F9oPk0cA0Bn2bmUwajgVlbZ/Hdz3cRnx1P88DmbIrdhFG5/J4tAI39GnMq/RTdIrpxY5sbaRfajkD3QAI9AgGYNQs+eNsT8kzHl65tN348PPecaQVtG0ajaU6SXg87dpiGyGVnw5YtsHq1/YDsJVEjRlgfHzpkGlbXoYNpWF1uLtx0k3XWJoQDKYqCPte0+lZBejrbZswgLynJdrU7RbGbRF0U1qMHjUaP5szp00S1bUtE797mVfSEEFUjNznXZpheyrEUFKPt/CYXLxdCO4RaDdMLbhOM1rXmv73ftSuOCRMWcbLEEuxPPdWT118fgE6ncWJktmr+/7YQwsRQCGm7IHUXJKyD87+BT+uKr3xnL5FSaYDilfW03qa9msKHQOgA8G4KwX3BLcju7c5mnOXJ1U+y6JDt/IqEnASbunre9Wjs15j6PvV5sueTtAhsgYfOA43a9MvTYICdO015zLsz4K+/TKPfcu2s3BoSAlOmQN9O2Yxa95hpPtFX9eHTT00rzPn7mxoajaZ5TBU1eTLccoup3Lmz9cIMQjiAoihkx8aSl5SESqWiMCuLk0uXknb0KD5NmpDw3394NWyISq0m68wZDPn55b63T+PG9Hj7bTRupk+sta6uuIeEoHF1NbcxGAyk7dlDveho1Jrq9QZGiJpMURTST6dbDdOL2x1H1vksu+09Qz1thukFNA1AdZWXAb8aPv98Bw8/vIrCQtMKuv7+bsybN4aRI1s4OTL7JJkSoiZRivc1StkKWSdMX8/9Vvoms2UlUq5B4BoIYddDUSbofMCzIeQnQYOxoNKahua5hYK6Ym+i8ory+HjbxyzYt4D9ifaTlMZ+jZnYZiKdwjuRr8+nU3gnWgS2QKcxffJtMJhG1J08AuvXm9Zr2LrV/uNdTKTacIA7+Ibewcfomr8eVVQ7eH+z/YvOnjX9K0tkpCkj8/eHQYOgZ0/Twg0hIWVfJ0QF6PPyOLNyJXFbtnD2jz8A8AgPJzcurszrsmNNH3xkHD9+2cfwrFePNlOnotZqaXD99bKIgxBXkaHIQPLhZJv9mwoy7M/zDYgKsFkYwius7iwUFBeXbU6kunaN4OefxxMZ6efcoMogyZQQ1ZnRAInr4eDrkLTJtHnq5ahdwVgA4UMhbAD4dTDVezUx/auCyaZrTq7hmz3fcCDxAHsTSk/g5gyfw6Q2k/HQ+PLjj5C8F/asNS0m9/Nm04i4qChTb1NpwrnAANYCpm10vd2KeDFoNuHnSmxke3Gtic12Eqnx46F1azhxwtSzdPFTeEWBVq0gKMhUJ/M+RBXKPHWKtKNH2fTEE3bP20uk3ENC0Li5kV38IUDDoUMJ79EDfV4ePk2aAGDU6/GsVw+P4GDUxa9tlVqNxsWlip6JEKKkwuxC4vfGW/U4JR5IxFBo+6GnWqcmpG2IecPbsOgwQjuE4urtaufOdceLL/Zl48aztG0bwrvvDsLFpXr3iksyJYSzFWVC4gY49gnkJ0Da7uIlwMv+VBqNB6jUphXxQvtD/bHg3wE0jp9kqigKZzLOkJaXht6o59k1z5Kcm0ygRyBrT60tO0yDFyMLfiDKOJIFj8L9m8p+rFPFE506sIdRLCMXD25gKZn4MIQ/bS/IB85dUjd2LLi4mHqWunUzJUh9+lRJIilEWXIuXOCf++/HNyoKQ0EB59eVsSEyENy5M54RETQeMQIXX1/UGg0+TZpYDb0TQlQP2QnZNsP0Uk+kgu30Jlx9XM3D8y5+DW4VjKaaJwpXw+HDSbRqFWw+1mjUrFx5c7VPoi6SZEqIqy39AMT/DbseK72NvUTKxR/qj4aWT4JvK1Mi5SApuSnEZ8ez/sx61Co1Oy/s5Mvdps02PXQe5BbZmZBkR4Rbc85v6QnHh5n+FXliAH4t45o2baBRI2jmn0zO8QvM3dqhfEFfcw0EBJjK+fmmOU+PPQZPPWXpbRKiiilGI0a9ntPLl6NSq0k7coTEnTvJPncOY2EhhgLTMB6bxR+KuQUG4t+6NX0/+kh6j4SophSjQtrJNJuFIbLjs+22947wtkqcwjuG49fYr9ovQ3615eQUMm3aSr7/fj8bNtxB9+71zedqSiIFkkwJUTWMBtNGtIfeBY0rHJ1lWgo8bVfZ16nU0GAchFwLQT3AxQ90vuAa4LDQ9sbv5cOtH/LniT+Jy75M7xfYJFIR3hEk5SZRaCikYdJUiuKbkXoykoLdEzhfxn2mTzd9LSiA226DtoFxuGxcCy+8ACtOl35hixamjMvFxdTL1Lgx9OsHxUs6C3G1FGZlEb95M3GbNnFh40byEmwXUCmNa0AAbe+7D8VgQKVWE9azJ77FQ/OEENWHodBA4sFE6/2b9sZTmGVnmL0KApsHWi8MER2GZ4jMSbycw4eTmDBhEQcPmsbl33jjYg4degBPz5r3oZIkU0I4Ss5pIuNfRbNwmf3zlyZSfu1ApYN+v4F7RJUNQUvKSaLrl105nX663Nf0i+xHVmEW9bzrMXPQTNy0bgR7BJOZ4snvv8Pa7fDTT1Da8g06HXz5Jdx4oykHUqkwzUk6e9a07PjL82D58rKDOHECmlTNHC8hylKYkcHZv/4iLzGRouxsjsybh0qrRdHb7ulyqXp9+5ITF0dot26EdumCW0AAAW3bSq+TENVQfkY+CXsTiNsdR8Ie09ekQ0kYi2y369C4aghtH2rV4xTaPhSXGvjm39l++GE/U6cuJyfHtE+kp6eON98cUCMTKZBkSogrd+gd2PMMGsD+4uBA62cg6zg0uQO0HqaepypMEtacXMPiQ4v5bOdnZbbr3bA3U9pPYUjUEBr6NrQ5n5sLs2dbepVKc+edprUbhg41dSIBcPQovL7ANOTuxRdLv7hePbhwAX7/HYYPv8wzE8IxCrOyOL9uHUm7d5Oybx9pR46U2f7SRMo9JISIfv0I7tyZen36oPXwkIRJiGpKURSy47JthumlnbS/z5qbv5s5abq4MERQyyDUWlmY6Erk5+t59NFVfP75TnNdmzbBLF48kZYtS30HVe1JMiVERRgNkLwZkjbC3ufsNlHUOlRN74FO/wPN1X1zpSgK6ldL/2X/6rWv8kj3R/Bxtb9zuNEIr74Kr7xy+cdq0QKeeQZuv71E5Z490HUqbN9++Rt07QrvvmsasidEFYr55ReSd++mMCOD2L//rtC1/i1b4h0ZidrFhWYTJ0ovkxDVnNFgJPVEqs3CELlJ9uf++jb0tfQ2Ffc4+Tb0lflNDnbiRCoTJixiz554c93tt0fzySdDa2yP1EWSTAlxOUYDJG+BYx/D2Z9Lb9b6OfYWDaZ9p15orsLmlidSTxCXFYdBMfDyPy+z/sx6u+3uv+Z+Ph32aZl/GAoLoUMHKOvD+SZN4McfTTmQWUwM/H7YtAnUjz+WfvHEiZCZaRob6Ot7mWcmRMUZDQZS9u0jIyYGjZsbW55+utzXhnTpgqufH/4tW1KvXz/cg4NxCwhAJcvjC1Gt6fP1JB5ItOpxStiXQFHx8LGSVGoVQa2CrHqcQjuE4hHo4YTI65Y//jjOpElLyMw0Lcjj7q7l00+HcccdHZ0cmWNIMiWEPad/hNML4MLK0tu4h0P4YIi6HwI6oSgqjHv2VFlIcVlxLD+2nHt/v7dc7ZUZdtZmLRYbCwMHQl4enLt0WfFiY8fCzJnQJNKAau0a2L0bVuTCpPmW9cvL8txzpuF9bo5fql2IU8uWEbd5M6eXL8cjLIzc+PjLXuPbrBm+UVG4+fvT+q678AgLuwqRCiEcIS8tz2rD2/jd8SQdTkIx2P6t07prCesQRmh0qHmYXki7EHTuOidELsLDvSkoMA2VbtEikEWLJtCuXaiTo3IcSaaEKMlYBD9dpru50wfQ7H7b/ZwMthvyXSmD0cCaU2sYvGBwqW2iAqIo0BcQmxnLlPZTuKfTPfRu2NuqzdKlcPy4aQhf7mVWOT+wX6FNC70pGYp6r3yBqlSmBSamToU5c2TDW3FFCtLTKcrKQp+XR0ZMDJmnTmEsKiLt6FEyjh8n58IFq/aXJlJaDw8C2rQhcft2+nz4IUHR0bgHByOEqP4URSEjNsM8PO/iwhAZZzLstvcI8rDauyksOozA5oGoNfJ3qLqIjg7jo4+Gsm7daebOHYF3LduUWJIpIfLiIPcc/NnV9pxXFLR6EpreBeqq/3FZe2otA78bSKB7ICl5KaW2e77P8zzT+xm8XLys6vPy4NAh2JVs2obpcq65Bp54AurXhwb1DEQe+wvaDS39Am9v6NQJMjLg8cdh1CgZtieuSGFmJjnnz3N6xQoOf/NNha8P6dKFyKFDCWzbFq8GDXDxsT8fUAhR/Rj1RlKOpRC3O464nXGc2HSCNTFryEvJs9ver7GfzcIQ3hHeMr+pmvnnn9P06tUAnc4y5eGeezpxzz2dauX3SpIpUfcUpkPmUVjdvex2kw0O3Rj3opzCHPbE72Fz7GZOpZ8i1DOUP078wdbzW81t7CVSLhoXkqcn4+3qba47cMC0aN748eV77GuuMeVDDz0EY8aAKu6CKZNSSh8SSPv2MG8eREeX8xkKYV9uYiKHv/mGo999V672Wnd39HmmN1XuwcEERUdTlJODX7NmBEVH0/D666syXCGEAxXlFpGwP8GqxylhXwL6fNstB9RaNcGtg60XhugQhpufDBuvzoqKDDz//FpmztzM9Ok9effdQeZztTGJukiSKVH7FaRC4nowFMDmyaW3cw2CgmSYkAU6r9LbVcK6U+tYcngJn27/tFztBzUZxMxBM1Gr1DQLbIab1voPyNtvw7PPln2PgABITTVt59S5M4SHX9Lgxx/hppvsXzx6NPz8s2mTKCEq4cTPPxO3ZQuxq1fj16IF6UePlus6j7Aw+syaRWDbtlUcoRCiquQm5xK/x3qYXsrRFBSj7Qd3Ll4uhHYIJbRDKIUBhXQZ2YWw9mFo3eQtak1y7lwmkyYtZtOmWABmztzMDTe0onv3+k6OrOrJK1XUPsYiOP4Z7HoUFNuN92wMPwS+rRwaQmJOIhMWTeDfM/+W2U6r1tKlXheiw6I5knyE8a3H80CXB2zaHTgA7dqVfp/QUEhJga+/hltuKWMLq507TUPzLplzAlgu1skEXVE5m595htN2NmO2l0gFtmtH9GOP4d+yJTofn1r9qaUQtZWiKKSfTrdZGCLzXKbd9p6hnqZV9EosDBEQFYBKrcJgMLBnzx7Co8Ovyoq4wnFWr47h5puXkpxsmpSt1aqZOXMQ3bpFODmyq0OSKVG7JG2Gv3qVfj6gC6Ruh+EHwbe1wx8+OT+Z2Ttm8/Cqh+2ebxvSlsZ+jVl641K0l5mDlZJiGpZ3+nTpbZ55Bl57DbSX+0nevv2SNc1L+PNPkOFSooIyYmKI27SJCxs24B0Zyally9Dn5Ni0C+7YEbfgYJqMHYvW3Z3QLl2cEK0Q4koZigwkH0m2GqYXvyee/PR8u+0DogKsFoYI7xiOV5hjR30I5zIYjLzyynpef/1f82yBhg19WbhwfJ3okbpIkilRe6QftE2kfNtC51kQNqDKHnbdqXV8tfsrvt//vd3z93S6h9ujb6dH/R6X/fT92DG47z5Yt670NosWQa9eEBZmpwcqP9+0bN/06aYkKSQEEhPt3+jdd+Gxx8qRiYm6ylBYyJkVK8iIiSlzcYj4zZutjgfNn49Xw4a4B9XcHe2FqMsKswtJ2GcannexxynxQCKGAttVa9U6NSFtQ8yJU3jHcELbh+LqU7tWbBPW4uOzuemmJaxbd9pcN3x4M+bNG0NgHdu7S95Fidrh4Fuw9znLceRN0HNBGePdKiezIJMtsVv4ZPsn/H7s9zLbDo0aysqby9inqoSzZyEysvTzmzdDjx52ThiNsHgx3HorFBTYnreXSCUlgbzJFaUwFBZyft06Nj7+eLmvcQsMJGrCBAozM2k3bRqufn5VF6AQwqGyE7JthumlHE8BO+sSufq4EhZdYv+mjmEEtwpG4yLD8uqSI0eS6d9/HvHx2QBoNCrefHMgTz7ZE7W67g3ZlmRK1FxGPRyfAzsvGVIXPhR62e8lqvRDKUb83vYjqzCr1DYNfBrQ3b87P075sczx3llZpk6jmBj4919YWUq+9dhj8N57pWzZlJVl6n36/PPSg27ZEh591LQKX5MmIPvsiDJknzvHssGl72fm1aABKrWaHm+/jWd4OBoXF1xkWXwhagzFqJB2Ms1mYYjsuGy77b3redsM0/Nr5IeqDr5ZFtaaNPGnYUNf4uOzqVfPm59+GkefPmV8IlzLSTIlag6jAdJ2Q9ouUOlg6522bbp+DlFTHfaQRYYihv8wnL9O/mX3/C3tb2HmoJmEeYWZJ89e6s8/TQvjxcbCX/ZvY+X4cYiKKj5QFJi/AH77zbS30/r1UFRk/8KGDeH992HECHCT5WNF+ez79FMOzJ5t95xP48YM++031DIZXIgaxVBoIOlQktUwvfg98RRmFdo2VkFg80CbhSE8QzyvfuCiRnBx0fDzz+OZPv0vPvlkGCF1/LUiyZSo/lJ3wqbJkHW89Db+HaHPUvBq5LCH3R23m05zO9nUn3/8PPW86132+rg4qHeZZj17Qnw83HsvPPVUiROKApMnw8KFlw/0ww/hkUcu306IS2ScPGk3kRr999942qylL4SojgoyC4jfWzxM7+L8poOJGItsV7PVuGoIbRdq1eMU2i4UFy/ZBkOUbtOms/j6utG2bYi5LjLSj59/nuDEqKoPSaZE9ZSXAOuHmxIpewK7gtYblCK4br1DH/rzHZ9z34r7bOrnDJ/DnR3vxEVT+h+dwkIV//ufiunTbc9ddx00bgyDBsG4caUM3ztzBmbOhE/t7Ef1wAPg7w9t2kDbtqbuK3f3CjwzIUxy4uJYd889ZJ46Za5re//9tJs2TZYoF6KaUhSF7Lhs8zC9i4lTWkya3fZufm6WDW+LF4YIbBGIRic9zaJ8jEaF99/fzLPPriEqKoDt2+/B21sWFrmUJFOiejEaYGVbyDxie86zEfT/E3yaV8lDK4qC+lXbDKdlUEsOTztc5rW5ufDVVyoefti2Jwvg/PkyeqlSU+HIEdP+Tykptuf37zclUPImVzhAXlISv113nVVdy9tuo/2DDzopIiHEpRSjQsrxFJuFIXISbbcfAPBp4GM9TK9jGL4NfeXDEVFpqal53H77ryxffgyAo0dT+OijrTz/fF8nR1b9SDIlqo/D78PuJ63r3MKgy6fQ4IYqeUiD0cANP9/AsqPLbM7d2/leHu/xOM0DbZO3oiI4dMi0yt6+ffDZZwDWiVhEhOlcQICdi9evh5tuMq2sZ09wMHTqBMuWgYsMvxBXRjEayTpzhszTp/n3kqSp35w5RPSVP45COIs+X0/igUSrhSHi98ZTlGM7P1alVhHUMshqmF5YdBgedWwpalG1tm07z8SJizhzJsNc9/zzfXj66d5OjKr6kmRKOF9BKiwJtK0ftg/82jn84WJSYxi8YDAxaTGltsl8JhNvV2+b+k2bTB1Iqaml3//ll43MmFGcWCkKbNsOCxaYlu27cAHy8uxfGBho6pk6cgRatKjIUxLCRnZsLMuGDEHj6orBzrL53pGRjCxtKUkhRJXIS8sjYa/1/k3Jh5Mx6m3nN2ndtYS2D7UaphfSLgSdu84JkYu6QFEUPv54G08+uZqi4jl3gYHuzJ8/lqFDmzk5uupLkinhPPo82HYvnJ5vXd97ETQc79CHis2IZcG+BTy39rlS22y7exvtQtvhprVdCS8mpsQKe5fw9IQ+feDRRw2EuvxL+2PHQGU756pUy5aZVuCT4RjiChgNBo588w2F2dkc+uILc729RCqkSxeu+/bbqxidEHWLoihknsu0DNMrTpzST6fbbe8e6G4ennexxymweSBqjb3JtUI4XkZGPnfdtYwlSyzTGnr2bMBPP42jQQPZBqMskkyJq6swA05+C7setT2n84EJGbb1V2jiooksOrTIpt5D58GySctoHticBr4NrM6tXg0JCaZ9oLZuNU1bKqlBA5g/H/r1K65QFJQhw1CtXl12MNOmQbNmcOONEBZ2Bc9KCEg5cIDdb79NbkICeQkJdtt4R0bS95NP8KxXD60smS+EwxkNRlKOptjs35SXYn8Ugl8jP5uFIbwjvGV+k3CawkID3bt/xZEjyea6J5/swZtvDkQnC5ZcliRTouopRtg8Bc78UHqb6Leh9dMOebiE7ARiM2P5cteXfL7TelNbF40LHcM6svLmlQS4XzqZCQoKyt6iqUMH2LMHOHYMRo40Lc/n6grLlmH3z+DChTBmjMx7ElcsPzWVYz/8wIE5c/CsX5+cc+c4WkrbwPbtQVG4/scf5Q2aEA5UlFtEwv4Eq4UhEvYloM/T27RVaVQEtw627nGKDsPNTz7UENWLi4uGO++M5qmn/sbPz41vvx3N6NEtnR1WjSHJlKg6WTGwvJSxcWBanW/YPtDZzk2qKEVRyC7Mxudtn1LbnH7kNJF+9nfoTkmBoCDb+uuuMy0yccMN8OzTRlrPeQhUJfblOXbM5hpDTAyaJk0q/ByEuJTRYODsqlVsttqEDHLOnbNp23T8eJqMGUNwx45XKzwharXclFybYXrJR5JRjIpNW52njrAOYVbD9ELahKB1k7dZomZ44omepKTkce+9nWnc2N/Z4dQo8lMuHC/rBBz9GI59ZHuuxaPQ+X8OfbixC8fy65Ffbeo9dB7kFuXy7nXvcnv07QR7Btu9/uBB07ZNl8rKAi8vYNs205ymBaWsvPfaa+DlhTE4mN0tWhAdaT9hE6I8FEUhPzmZX669ttQ2zW+9lWxfX9r26UNQmzZXLzghaiFFUcg4k2Gzf1NmbKbd9p4hnjbD9AKiAlCppRdY1AwHDiSyZUss99zT2VynVqt4++3ryrhKlEaSKeEYRgNsvxdivrI9F9AZrl0JbiG2565Aen46/u/Y//Qk//l8XLVlbyyXlgYvvmi7P25aGvj5AYmJ0Koz2OkFYNQo0wp93pZeNcVgKB4DKET5KYrCnvff5/A335TZzjMigpErVqDW6TAYDOzZswf/ljIMQ9Q9Rr2RwuxCu/8Ksgrs1hdlF5V+PqsQfb7tMD0A/6b+NgtDeIdf+WgKIZxl3rw93H//CgoKDERFBdC/f2Nnh1TjSTIlrlzGEVjRyrZe4wE9F0CDsQ59uPjseFp/2pq0fOtd3w9PO0xD34Z46Mq338al+z9NmwaffIJpzN/T78K771o3GDAAPvwQ2jl+uXZRtyiKwoE5czj8zTfoc3PLbDtx+3a0HrKHjKg9FKNCwv4Ekg4m2U2ELiY+pSVKhgKDw2NS69SEtAmx6nEK6xCGq0/ZH8oJUVPk5hbx0EMr+frrPea6d97ZJMmUA0gyJa7M7ulw+D3ruh7zofEtVfJwBfoCwt8Pt6nXv6hHoy7fijNGI2guafrQQ/DRR5gWjJg0yfqkjw+sWAG9ZbM6UXkXNmzgn/vKXjK/4dChtL7jDnyaNEHr7n6VIhOial1Mnk7/c5oz/5zh9PrT5KflX/F91Vo1Lt4uuHiZ/rl6u5rLLl4u6Lx0VseltvPU4RPhg8ZFVi0TtdPRo8lMmLCI/fsTzXX33NOJWbOGODGq2kOSKVFxRj1suAHOL7eub3SzqSeqihxIPEC7Oda9QqtuXsXgqMHlvsfff8OgQaayCiPd+Y81Kwtxf/15UG22veCuu+DLL68kbFGHnf/3X7bNmEFeYmKpbbwaNKDrjBmE9ehxFSMTouoU5RWRcjSF0+tLT55cvFwI7xyOu797mYmPveTn4j9JfoS4vJ9+OsA99ywnO7sQAA8PHZ9/PoJbbmnv5MhqD0mmRPkZ9bDrMTj2ie25/n9C+PVV9tBHk4/aJFLKDNsVlezR62H0aFi50nTsQQ7b6EobDpkqhtm5aOVKGDr0CiIWdVH6sWMkbN/O7pkzMRYV2W3TaNQomo4Zg1eDBnjWq3eVIxSibIqiYCgwoM/Xoy/QU5BTQPaZbBLUCShFCvoCvelcvp6chBwyz2WSeT6TrPNZZJ4zfc1Ltd1fSeepI7JPJJHXRtLo2kaEdwpHI/vXCFFl8vP1PP74n8yZs8Nc17p1MIsWTaB1a/sLconKkWRKlE9p86L6LIX6Y6CK9rIpMhTh8rr1Hk2eOk+yns0q1/W+vpBZvCDTs7zJmzxvv2FYGMTHwx13wBdf2I4DFKIURoOBJb17U5Rpf+UvAI2rKx0eeYQWU6agUquvYnSiLjEUGUg+kkzCvgQS9iWQm5SLPl9vlRxdTIQurbt4bCi0Px/pH/6pUCwu3i407NVQkichnOSee5azYME+8/GUKe2ZM2c4np6y76WjSTIlLi9lB/zZxbqu25fQ9K4qf+hLE6mBjQfy+02/l2sj0otNvMgii1L2n4qJAdkTSlTC8Z9+Yvtrr9k9p3FzQ+vmRr85cwhqL0MphOPlpuSSsDeB+L3xJOxNIGFvAkmHkkpNhipL66YFLbh6uqJ11aJ106Jx1aB11eIZ4ol3hDfeEd741PfBJ8IHn/o+eEd44+bnJhtGC+FEzz3Xm19+OYzBoPDJJ0O5886O8jNZRSSZEmU7/AHsfsJyHDoQBv5d5Q+blpdGwLvWy+0VvlCITqMr87r4eJg6FZYXT+caxGpWc8mcqpkz4dFHQSsvf1FxyXv3svqmm+yeG/7bb/hGlbFRtRAVZDQYST2eapU0xe+NJ+u8/d55F28XwjqEEdI+BN8GvmjdSiRAblrrhMjecYk6tU6N0Whkz549REdHo5EeeyFqjFatgvn++xto1MiPDh3CnB1OrSbvJkXpYpdaJ1J+7ao8kVIUhQX7FnDrr7da1RtfMpb5iUpcHFhPP1HYQzQd2Gfd0GAAGWYlKuH4woVsf/VVm/oe77xDWLduuAfLGHRROYqikB2XTfLRZFKOpZB6PJXU46mkHE8hLSat1N4m/yb+hHYIJbRDKGEdwgjtEIpfIz/59FmIOubs2Qxee209H388DDc3y1v70aNlL8KrQZIpYV/cX7BhnOV4wF8QVrU7Y3+39ztu+/U2m/qyFpr4+GN4+GHrus+4l3uZa105eTL88IMjwhR1zNk//2Tj44/bPTd+82ZcfH2vckSiprqYNF2c05S4P5HEg4mkHEuhKMf+giUAOg8dIe1CrJKm0HahsgeSEIIVK45x662/kpqah06nYfbs4c4Oqc6RZErYd+JzS7nXwipNpAxGA/+e+dcmkeoU3okNd2ywe82aNabRen/+aalrxClOYWf+0+nTEBnpwIhFbZeflsaud97h9PLlNueu//FHmQclLqswp5Ckg0kk7C9OnPYlkrAvwe5KdwAqjQr/xv4ENg8koHkAgc0CCWhm+urTwAe1RnrUhRAWer2RF19cy9tvbzLXrVp1gvT0fPz83JwYWd0jyZSwFf83xC4xlf07QuTEKnuoNSfXcN1860Ttx3E/MqntJLvt//sPLt2OZyxLWco428YLFsBNN1XZSoOidkk7coS4jRvZ87//2T3vFhjI4IUL8Qy33TRa1C2FOYXmpcAzz2eavp7LJOtclvk4JyHH7rUqtYrAFoGEtg8lpF0IIW1DCGoZhH9jf9k3SQhRLhcuZDFp0mI2bDhrrhszpiXffDNaEiknkGRKWOx4GI59bF3XanqVPdx7m99j+l/W95/QekKpiVRhoW0i9ajbZ/wv/37ryttug2+/dWCkojbLuXCB3y7u5GxH+4ceovXdd6OWBUtqPUVRyE/PtyRHFxOmS8r56fmXvxngEexhXgwitL1paF5QqyB07mUvpCOEEKX5668Ybr55KUlJuQBotWreffc6Hn20u8yXdBJ5d1DX6XPhZ0/757p+AY0mO/whv9/3Pbf8cotV3YeDP+SR7o/YbW+7uAS0aqlw6IgaSr6nufZaeOcd6NrVsQGLWkdRFFaNH0/akSN2zzccOpReM2fKH6ZaRDEq5CTm2PYmlUiSMs9los/Tl+t+Ok+daTnw+pblwM3HET74NPDBM7iU361CCFFBBoOR1177l1dfXY9SPJW8fn0ffv55PD16NHBucHWcJFN1WUEKLAmyre+92LQRr9rxQ042nd1kk0j9d9d/dKvfzaZtWhoEBFxaqzCWX1h65JJhfc89B2+84dhgRa2jGI1kx8ayfNgwu+cn7d0rPVA1VGF2IYkHE8k4k2FOmLLOlehZupCFUW8s173cA9ztJ0kljl19XCXZFkJcNd9+u4dXXllvPh46NIrvvhtLUJCHE6MSIMlU3bXnWTj0tnXdqJPg1bhKHk5RFNSvWk+gfq3/a7zQ94VSrymZSPViI99xG004adtQljsXpTDq9cRt2sSud94h68wZu22u/ewz6vXpc5UjE5VlKDSQciyFhP0JJB5INK2IdyCR9FPpl79YBV5hXqX3JhXXyTA8IUR1c9tt0cyfv48NG87y+uv9efrp3qjV8oFOdSDJVF2kz7NOpDwjYfTpKnu47MJsvN/ytqq7q+NdpSZSKSkQVNxhFsE5zlFK9/VNN5kWmZBPh0Uxo17Png8+4Mi8eYR06ULi9u1ltp+0Zw9qnbxxro4Uo0L6mXRzsnTxa/LRZIxF9nuYPEM9CWwWWGpvkleYFxqdLPIghKh5tFo1P/44juPHU+nbV1York4kmapLcs/DzkchdrGlru8yqD+yyh5yS+wWen7d06qurH2j0tMtiZQLBbaJlKsrvPQSPPOM9EYJK0e//56db75pPr40kdK4udH2vvtoMnYsboGBMkSrGlIUhS0fbOHQokMkHUyiMLvQbjtXH1dC2oYQ3DaY0HahhLQ1rYrnIcNdhBC1QEpKLnffvZznnutNly4R5vrwcG/Cw73LuFI4gyRTdUXGYVjR2rrOPaJKE6n0/HSbRKrghYJS2586Bc2bFPE+T3Mz36Mv+fKMjoadOyWBEjZy4+P5deBAm/qGQ4ZQv39//Fu3xreJnf3HRLVSkFnAn4//ye6vdpvrNC4agloFmZKl4mXEQ9uF4tPAR5JhIUSttGVLLDfeuJjY2Ez27Iln166p+Pu7OzssUQZJpuqCnFjbRKrLHGh2X5U9ZN9v+rLhrGXD3bs73s0Xo76w2/boUfhfy8/4jPspstegRQvYvdveGVHH/fPAA1xYv96qruP06bS6/XbnBCQqrDC7kIOLDvLva/+a5z0NeGMALce2JLBZIGqtfIAihKj9FEXhww//46mn/kZfvFhOTk4hMTFpXHONJFPVmSRTtZ2iwG8NLccNb4TeP1XpQ0Z/Fs3ehL3m4zbBbewmUnq9aZGJt7Km8RmzbW80ciRMmQK9elVluKIGMhQWsvnpp60SKY/wcEb98YfMgapBEvYl8P3Q78m6kAWAb6Qvo74aRZOB0pMohKg70tLyuPPOZfz6q2W7jj59GvLTT+OpV0+G9VV3kkzVdksCLWW30CpNpI6lHKPFJy2s6tbfvp6+kX1t2sbGQsOGEEAK00okUtndBuD16/cQFlZlcYqa68LGjZxevpzTv/9uVT9owQKCO3Z0UlSiohRF4cz6Mywcu5D89Hx8I33pdE8nuk7ripufm7PDE0KIq2bHjgtMnLiIUyVWJH3mmV689toAtNIzXyNIMlWb/VIfCtMsx2PjquyhjiQfodWnrazqjj90nKiAKPOx0QgPPQSzS3RC/cQky8HGjXhJL5SwQzEa+bFdO7vnBnz1lSRSNUBBVgGn1p7ixKoTxKyKIf10OgANejVg8vLJuMucACFEHaIoCrNnb+fxx1dTWGgAwN/fjfnzxzJ8eHMnRycqQpKp2mp5c8g7bzmemFNlS4gbFaNNIlX0YhFatenlpShw8iRERdleO4i/LQeSSIkSci5c4Ny6dVYr9F0U3LkzURMn0njECCdEJspDURQS9iWYk6ezG89abZqrcdHQZmIbRnw+Ap2HDM0UQtQtMTFpVolU9+71WbhwPA0b+jo5MlFRkkzVRklbIOu45XhcCmirZslgg9GA9jXLyyjMK4zTj5w2J1LffAN33ml73axZcP8XHeFAccWrr1ZJfKLmSdy5k79vvbXU85P370clqzpWS3mpecT8FUPMqhhOrDpBdny21fmAqACaDmlK1JAoGl3bCBdPFydFKoQQzhUVFcD//jeYadNW8thj3Xn77etwcZF98GoiSaZqo+0lVumbkAE6nyp5mLyiPDzetE7S4p4wDSVMSoKQENtrGjaEMx/9BmPGWJ94/vkqiVHUHMaiIuI2b2b9Aw9Y1au1WjTu7gz75Rc8w8OdFJ2wx2gwcmHHBXPv0/lt51GMln3kdB46Gg9obEqgBkcREBXgxGiFEMJ5FEVBUUCttowSuv/+a+jUKZzu3es7MTJxpSSZqm1yzkL6PlPZt22VJVKZBZn4vm3dFX1xM97Tp6FxY+v2t90G375+Dp59FsYssD559KjsH1WHZcfGsmzIEJt632bNGLZ0qfRCVTPZ8dmc+NOUPMWsjiEvNc/qfEjbEHPvU8PeDdG6yp8ZIUTdlp1dyP33r6B+fW/eeus6c71KpZJEqhaQv3K1zW+RlnKfJVXyEJMWT2LhwYVWdbGPxWIwgNbOK0pRMM3XmnfJiQ8+gMceq5IYRfWmKAoH585l30cf2T3f58MPaTBo0FWOSthjKDIQuznW3PsUvyfe6ryrrytNBzU19z751K+aD3CEEKImOnQoifHjf+bw4WQAevduKAtM1DKSTNUmW263PvZx7A/rxrMb6fNNH6u6lkEtOTztMHfcAd9+a91+xAhY/v4xUFkvlw7AG29IIlVHGQoLWTZkCHkJCVb1rgEBDF28GLegINQaGTfuTOln0s3J08k1JynMKrQ6X++aeubep/rd6svGukIIYcf8+Xu5774V5OYWAeDl5UJ+vt7JUQlHk2SqtohfA6dKdP1MyHDYrY2KEc2rtm9u542Zx81tb7W7SGBiIgQbEyDskkQqNxfcZQnkuuqHNm1s6tpMnUqbe+9F6yb7CzlTwv4E9ny7hxMrT5B8JNnqnEewB1GDo2g6pClNBzXFM8TTSVEKIUT1l5dXxCOPrOKLL3aZ69q1C2HRogm0aBHkxMhEVZBkqjbQ58Fayxhcrt/i0LlSz615zup4RPMRLJ+8nNxc22F9v/8Ow4cXH7S61nLitttsu65EnZGwfTtrbr/dpv66efMIueaaqx+QQFEU4vfEc3TZUY4tP0bcTss+dCqNigY9Gph7n8I7hqNSV83WCkIIUZscP57ChAmL2LvXMvrirrs68vHHQ3F3l20gaiNJpmqDn0usqNfhDQjq7tDbv7PpHXPZ8JIBtUrN2bMQGWndzmgssZVVeDjEF8+taNdOEqk6zF5v1I27d6NxkWWxrzZ9vp5T605xbPkxji0/Rua5TPM5tVZNyzEtaTOpDU0GNsHNT3oKhRCiIhYtOshddy0jq3hotIeHjjlzhnPrrR2cHJmoSpJM1XRxf1nKHvWhzXOlt62EOdvnmMsv9X0Jtco0N+Laa63bKUqJg8RESyIFsHSpQ2MSNce6qVOtjuv168e1s2c7KZq6KScph+MrjnN02VFiVsdQlFNkPqfz0NH0+qY0H9Wc5sOby/A9IYSoJIPByLvvbjYnUq1aBbFo0QTatLGzT4yoVSSZqsmMBlh3veV4TKxDb28wGnhgpWXPn2ldpwGmxOnUKUs7q0TKYIDQUMvx4cMQFeXQuETNUJSTQ9ymTebjyQcOoLI3wU44lKIoJB9O5ujyoxxbdozYLbFQ4mfUu543zUc1p8XIFjQe0Bitm/wZEEKIK6XRqPn55/F07Pg5I0e2YM6c4Xh5yQiMukD+itZkP5X49jW73+G3P5R0yFz+bdJvhHiGkJEBfn6WNtu2lbggLw88Sgw57NoVWrZ0eFyiZtj1jmV46IgVKySRqkKGIgNnN5w1JVDLj5EWk2Z1PrxTOM1HNqfFqBaEdQyT74UQQjhAbm4RHh6WeVCNG/uzd+99NGzoK79n6xBJpmqq+LXWx10cO3Rqd9xuOs3tZD4e1WIUYJ1IAXTpUlw4cgRatbI+uXWrQ2MSNUv6sWPmsk+jRs4LpJZSDAqHFh3i2LJjHF95nIKMAvM5jauGxgMa02JUC5qPaC57PwkhhAMVFRl45pm/WbUqhm3b7sbT09IDFRnp57zAhFNIMlVTrR1oKd+klN6uggxGAzf8fAPLji4z14V6mobtXfohy/r1xYX0dNtEymh0WEyiZkrZvx+AFrfc4uRIap+0U2lsnrqZtL2WHiiPYA+aj2hO85HNaTqoKS4yvEQIIRwuNjaDG29czJYt5wC4//4VzJs3Rnqi6jBJpmqikpvzhg912G31Rj2616yX7WwT3IY14/bbJFLp6eDrC6xdCwNLJHbTpsEnnzgsJlGzFOXkUJCeTvLu3ea60G7dnBhR7XNoySF+u/03CrMLcfF2ocsDXWgxqgUR3SJQa2TzXCGEqCp//HGcKVN+ISUlDwCdTk2XLvWcHJVwNkmmapqCFOvNefuvdNitP/zvQ6vjzXdupkeDHjaJVE5O8dSo48etE6mGDSWRqmMUo5H0o0fZP3s259autdum/oABVzmq2uvAwgMsvXkpikEhIDqAyYsmExQlG0AKIURV0uuNzJixjjff3Giui4z0ZdGiCXTpEuHEyER1IMlUTbO0xEp5fZeV3q4CFEVhwqIJLDm8xFI3wzR0sGQipdVC0cVVlQ8fhtatLSd/+AEmT3ZIPKJmuLBhA//cd5/dcxo3Nwz5+XR56aWrHFXtlHIshdVPrubYctM8tPa3tqfBtAb4N/Z3cmRCCFG7xcVlMXnyEtavP2OuGzmyOfPmjcHf392JkYnqQpKpmkRRQDEUH6ig/sgrvmV2YTY3L73Zao7U4gmLURQIC7Num5uLKZu6dLPVjh0lkaojDAUFnP79d7aWkiRFP/EELW+9FbVWfrU4Ql5aHutfXc/2T7Zj1BtRa9V0e6Qb/d/sz779+5wdnhBC1Gpr1pzkppuWkpiYA4BGo+Kdd67j8cd7yBwpYSbveGqSk99YytetL71dBXy89WOrROrwtMOsWdgSdRvrdkUFRrTDBsPff1ufuOYa2L7dIbGI6kkxGtn51lsc++EHu+fbTZtGuwcesHtOVI6hyMDOz3fyz4x/yEs1jc1vNrwZ1793PUEtgzAYDJe5gxBCiCu1bdt5cyIVEeHNwoXj6dWroZOjEtWNJFM1hdEAW++yHAf3vuJb6o16nlv7nPn44AMHiT/QkgcftG63f2MGWlc/2xuYV6EQtdmP7drZra/Xty/9Zs+WT+cc7Pgfx1n9xGqSDycDENwmmMEfDKbp9U2dHJkQQtQtTz/dmw0bzqIoMH/+WIKCPC5/kahzJJmqKUpu0BvQ2Xad8kr4Zrelp+uJNh/SJqS11fmnn4bXXjGic/OzvnDFChg27IofX1RfMUuW2B3K1/ymm+j83HOSQFWBpENJrH5iNSdWnQDAI8iD/q/1p9PdnVBrZZU+IYSoanFxWYSHe5uP1WoVP/88AQ8PHWq1/N0T9kkyVRNcWGV9fP0Wh9z23t/vNZffn/CI1bmZM+HJJwGVxvoixXF7WonqJ/avv9jw6KN2z41dvx73IFk5ztHy0vJY9+I6dny2A8WgoNap6fZwN/q+0Bc3PzdnhyeEELWe0agwc+YmZsz4h9Wrp9C3b6T5nJfs2ScuQ5KpmmCbJelhkh7UmtLbVoBCcWIU38Fc16oV7N8PGg2mHqiSZCPeWqkwM5OcCxf4Y9w4m3PuwcEMmj8frwYNnBBZ7aYoCvt/2M/qx1eTUzwmv+WYlgyaOYiAqAAnRyeEEHVDSkout976KytXHgdg0qTF7Nt3vwzpE+UmyVRNkHvW9DW49xUnUoqiEPFBBHHZcZbKta8BMGMGvPxyicbrSyxykZfnkKGFonpI2r2bMytXlrqohHtwMGPWrkWlluFlVSHlWAorHljBqTWnAAhqGcSwT4fReEBjJ0cmhBB1x3//nWPixEXExmYCprc5d9/dCX9/GRUgyk+SqeouvsRGqC0evqJbPbfmOd7a+JbtiZODMBjA5n3zzJmmr40agZv8YqnpCtLTWdKrV6nndd7eFGVlMWnPHtQ63VWMrO7Q5+vZ+M5GNr65EUOhAa2blj4v9KHX9F5oXBzT4yyEEKJsiqIwa9ZWpk//C73eNOomKMiDBQvGMnhwlJOjEzWNJFPV3a7HLeUGtsOwyuvLXV/aJlLvJkJuMAsW2Emkfv/dUu7atdKPK5wvafdu/nngAYoyM23O+TRujEd4OP3nzpVFJarYyb9PsuKBFaQeTwWg6eCmDPt0GAFNZUifEEJcLenp+dx552/88ssRc13v3g358cdx1K/v48TIRE0lyVR1ln4A0vdajlWVG3KVW5TLPcvvsVTM3QYXugAwZAjcfPMlF6SlwcgSGwLPnl2pxxXOZdTr+X3ECLJjY23OjfzjD7wbyl4ZV0PqiVTWvbSOAz8eAMAr3IshHw6h9YTWksAKIcRVtHdvPDfc8DMnT6aZ6556qievvz4AnU5GB4jKkWSqOvu7r6U8bH+lbvHfuf/o8VUPS8X6F82J1FtvwTPP2LkooMQn5W++CYGBlXps4Tz5KSks7dvXqi60e3d6vPkmHqGhToqqbkk9kcq/r//LvgX7UAwKqKDrg13p/1p/3Hxl2KwQQlxtWq2auLgsAPz93fjuu7GMGNHcyVGJmk6SqepKUaCw+JMTtQ782lbqNsO+t94Pavo1r/Lu2lIaA3hcsnrNs89W6nGFc+RcuMCm6dNJ3rPHqv76H38kqH175wRVx9gkUUCz4c3o/2p/wjuFOzk6IYSou9q0CWHOnOHMnr2Dn38eT2Skn7NDErWAJFPV1ZZbLeV+K0pvV4Yf9v9AWn5xQrb3FvhlPu+Utbr59debVu276MKFSj2uuPpi16xhw8P2FyiZtHcvaq38qFe19NPprH9tPXvn7bVKovrN6EdElwgnRyeEEHXP4cNJNGnij6ur5W/gbbdFc/PN7dHKZujCQeQdVnW0/UE4vcByHD6oUre5eWmJyVB/fMScOWWsbv799/DXX5Zjvb54sylRnRn1en7q0MGmPqBNG/p8+CGe9eo5Iaq6JfN8Jhve2MCuL3dhLDJ9WhE1NIprX7lWkighhHCSb77ZzQMPrOSeezrx0UdDrc5JIiUcSZKp6saoh+OfWo5HHCm9bRmaf1xiDPDGpyHfn/vuK6VxQgLccovl+NgxSaSqOUNBAQnbt/PPvfda1UdNnEinp55C6+7upMjqjuz4bDa+vZEdn+3AUGAAoPHAxvR/rT8Nesgmx0II4Qw5OYVMm7aSefNMC3h9/PE2hgyJYtiwZk6OTNRWkkxVN+tHWcqDNoJPiwrfQvXKJd1Pf79F//5lXBAWZil//jk0k1841VVeUhIrx4yhID3d5tzEHTskiapCiqKQsDeB2C2xHP3tKKfWnjL3RDXs05D+r/WnUb9Gzg1SCCHqsMOHk5gwYREHDyaZ6+69tzMDZEN0UYUkmapOjHqI+8NyHFz6BqulydfnW1d8vgNQ8dxzpVzQsqX18dSpFX5MUfUyT5/m5K+/cuiLL2zOdXrqKVredpsToqo74vfE8+fjf3J63Wmr+ohuEfR/rT9Nrmsiy5wLIYQT/fDDfqZOXU5OThEAnp465s4dyU03tXNyZKK2k2SqOvlJZyn3/a1StziQeMBy8FoBGFwAuO46O41zc+HoUctxVlalHlNUjZy4OPbOmsXp5cvtnh/9118yJ6qK5afn8+cTf7Lnmz2ggFqrpn73+jQb0YyWo1sS1DLI2SEKIUSdlp+v59FHV/H55zvNdW3aBLN48URayu9ocRVIMlVdbL2kR6j+KPvtLuNsxllTwaAzJ1IFBaU0XlBikYv4ePDyqtRjCsfb/f77HP76a7vnGo0cSc+3377KEdU9BVkFLBi8gPPbzgPQdnJbBr41ED9ZSlcIIaqFhIRshgz5nj174s11t98ezaefDsPDQ1fGlUI4jiRT1UVMieFbN5aW/ZStyFDEuJ/HmQ5Uprkcd98NLi52GisKlFy8QDZyrTYMhYU2iVSzyZPp8sILToqo7inKLeLHkT9yftt53APcmbRsEg17NXR2WEIIIUoICHDHy8v0JsfdXcunnw7jjjs6OjkqUddIMlUdXNycF6Dje6Cxl/1c3pwdcywHe24HTOtJ2BUZaSn37FmpxxOOU5iRwZbnnuP8P/9Y1Q/6/nuCo6OdElNdZSg08PP4nzmz/gwu3i7c8uct1LtGhlMKIUR1o9Np+OmncUyatITZs4fRrp18MCyuPkmmqoPYXy3lFo9U6haKovDIqhLXLvuSuDhQ29tKoaAAYmMtx3//XanHFI6RtHs3f5Vcmr4ESaSurqK8In6Z8gsn/jiB1l3LzStvlkRKCCGqidOn08nKKrBKmiIifNiw4Q4nRiXqOkmmnM2QD1vvtByrK/ctuXf5A5aDFaZ9qkqueG55PAO4uVmOz58HWU7bafJTUmwSqeY330yziRPxjYpyUlR1j6HIwK4vdvHv6/+SHZeNxkXDpN8m0bC3DO0TQojqYNmyo9x2268EBLizc+dU/PzcLn+REFeBJFPOtrBEIhPQuVK3SMtL44vdn1kqtj/AhQt2GioKhIdb18lqcE5zeuVKNk+fbj6OfvxxWt91lxMjqpvObT3H7/f+TsLeBAB8I30Z8fkImg5q6uTIhBBCFBUZeP75tcycuRmA9PR8XnxxLR9/PMzJkQlhIslUdTJkR6UuC3+/RIK0cAmKYqeRotiO+bPbUFS1vKQkfrn2Wqs6nY+PJFJXWea5TDa8uYEdn+0ABdwD3Ln2lWvpdE8ntK7yq1EIIZzt3LlMbrxxMZs3W6YmjBvXitdfH+DEqISwJu8YnCnPspQnAyo3b2n+3vkUGCyr/6355Ab7DS9NpDZurNTjiSuzcuxY0o8ds6rrOmMGURMnOimiuif1RCob397I3u/2YiwyrXrZfkp7rn//ejyDPZ0cnRBCCIA//zzBLbf8QnJyLgA6nZr33ruehx7qKpuki2rFKclUSkoKL774Itu2bUOj0TBq1CiefvpptFrbcObNm8e8efNIT08nIiKCBx98kMGDBzsh6irwS4kepaDuFb5849mN3PrrrZaKj48wYIadhtnZ1sdGI8gvoqsu9dAhq0TKp0kThi5Zgsbu2vWiKsTtiuPr3l+jz9MDENk3kn4v96Nx/8ZOjkwIIQSAwWDk5ZfX88YbG8wDaBo29OXnn8fTrVt95wYnhB1OSaYeffRRQkND2bBhA8nJydx///18++233H333Vbt1q9fz+eff86CBQto0qQJf/75J48++ih//fUX9evX8B+oksuhA2gr9ol4en46fb7pY6mYvwpjUgv7jb29LeVTpySRusoStm3jvxdfJOfcOXPd0KVL8W9RyvdLOJyiKJz+5zTfDfgOgKCWQYz6ahQNejZwcmRCCCEuUhSFkSN/YvXqk+a6ESOaM2/eGAICZLEsUT1d9WTqzJkzbNu2jX///Rd3d3caNGjAAw88wMyZM22SqZMnT6IoivmfRqNBp9PZ7cGqcf4s0RM1MafCl9+89GbLwT8vQcxg+zlSiTfwADRqVOHHEhWXl5zMgdmzOb5woc25VnfcIYnUVWI0GDm89DCb393MhR2mVVlUGhVDPxkqiZQQQlQzKpWKoUOjWL36JBqNirfeGsgTT/RErZYPgUX1ddWzkuPHj+Pn50doqGWPgKZNm3LhwgUyMzPx8fEx1w8fPpylS5cybNgwNBoNKpWKmTNnEmZ3ze+yGQwGDAaDQ56DI2iyLMO9DCpX05Ll5fT82udZeXylpeKfl9HrDXZvoX7oIS7+CjIUFFTocUTFXHx9ZcfFscLOUFSP8HA6PfMMEf37V6vXYm1UlFfEvu/28d8H/5EWY+oF1rpp6XBHB7o92o2ApgE1+ntwMfaa/BxEzSCvNXG1XHyN3X9/J44fT2XixNb07t0QRTHKWxfhUI7+fXbVk6mcnBzcL9nX6OJxbm6uVTJVVFREy5YteeONN2jZsiXLly/n+eefp2nTprSo4Cf7hw4duvLgHcQneyPNissn6r1Hxp495b72mxPf8OmRTy0Vv88GVOwp5R6df/3VXN6zf39FQxWVYJVIqVR4de5M+NSpqN3cSAKSKvD9FhVTmFnImUVnOLXwFIWphQDofHU0mtiIRhMb4ervytmss5zdc9bJkTrGfvmZFleJvNZEVUhLK2DLliSGDbNM3Thw4AB33hkGpLJnT6rzghOinK56MuXh4UFeXp5V3cVjT0/reUOvvfYanTp1on379gCMGzeO33//nV9++YVnnnmmQo/bunVrXKrJRH/Vru/M5cZ9Hi33dQajgU9/L5FIrfof7L6ToiIDKlW07QW7d5uLxrvvJjraThvhMAaDgZUlNuB19fdnzPr1Toyo7siIzWDbh9vY9eUuinKKAPBp6EP3x7oTfUc0Ll7V42ffUQwGA/v376ddu3ZoNBpnhyNqMXmtiaqyceNZbr/9Fy5cyKJz51Zcd10jea2Jq6KwsNChnSxXPZlq1qwZ6enpJCcnExQUBEBMTAxhYWF4l1woAbhw4QJt27a1qtNqteh0ugo/rkajqR4/nIoCxz8ylf3K/wtDb9Tj+qarpWLBSjgxlGnTwO4UMqMRunQxH6rnzIHq8PxrqZ1vv83R+fOt6m7YsEGWb61iiQcS2TxzM/t/2I9Rb1rmPLR9KD2f6kmbiW3Q6Gr3a77a/F4TtZ681oSjGI0K77+/mWefXYPBYFqu76mn/mb37qmAvNZE1XP06+uqJ1ONGjWic+fOvPnmm7z66qukpaUxe/Zsxo8fb9N2wIABLFiwgP79+9OqVStWr17N1q1befzxx6922I7zW6Sl7N+x3Jf1+rqXdcWJoQDcdFMpF5R8oTz9dCkZl3CE9dOmcf6ff6zqhi9fLolUFVEUhbMbzrLp3U0cX3HcXN+ofyN6PdWLpoObyv+9EEJUQ6mpedx++68sX26ZN96vXyQ//jhOFpkQNZZT3mF/9NFHvPrqqwwcOBC1Ws2YMWN44IEHAOjYsSOvvPIKo0aN4sEHH0Sj0fDQQw+RkZFBZGQkn376Ka1atXJG2I6hL7FyX9fPy3WJoihsO7/NUvGyYi727GnT2LYH6u23KxikKK/8tDSrRCriscfodfvttWPFyWpGMSoc+e0Im9/dzLn/ilepVEHrca3pOb0nEV0jnBugEEKIUm3bdp6JExdx5kyGue755/vw8svXotWqZZETUWM55R1fUFAQH330kd1zu0vM89FqtTz00EM89NBDVyu0qnVkFhQWT6bs9zto3Mp12ec7SyRd8/80F1NS7DRWq62P9foKBinKw1BYyMKO1j2Lo9as4ej589Ir4mD6Aj375u9j88zNpBwzveg1rhqib4+mxxM9CGwW6OQIhRBClEZRFD7+eBtPPrmaoiLTcOzAQHcWLLiBIUOinBydEFdOPj6/mnY9aimH9Cv/ZXG7LAcxgwC4cAECAi5pmJFhfZySIvOkqsDejz7i4OfWvYpuQUG4BwfD+fNOiqr2MRqM/Pfhf2x5bwvZ8dkAuPm5cc0D19Dt4W54hXo5OUIhhBCX8+KL63jjjQ3m4549G/DTT+No0MDXiVEJ4TiSTF0tMV9byu1eBV353wh+sesLUyEuGlBhMNh2QAHg52cp5+SAh0clAhWlyUtO5pd+tknw5P37UalliIKjbXpnE2ufXwuAT30fuj/enU53d8LV2/UyVwohhKgubr89mo8+2kpWViFPPtmDN98ciK6WLw4k6hZJpq6G7NOw9S7LcZvyL+v+9e4SSdipAVy4UEoiFRxsfSyJlEPtnz2b/Z9+alXXcfp0Wt52mwzrczDFqHBsxTFzIjXw7YH0eKwHGhf54yuEEDVNVFQA3303FpUKRo9u6exwhHA4SaauhnXXW8ptZ4C6/Eu7/3O0xBC/9TMID7fTSFEgOdlyLPOkHOrgF19YJVIBbdsyZOFCJ0ZUO2UnZLPnmz3s+mIXaSfTAAjtEEqvp3pJwiqEEDVAdnYhb765gRde6IuHh+W9zpgxkkSJ2kuSqavBWCK5af9yuS/Ly4P5R4vfxO++nZ/n+9hvWLKr6uxZmSflQPlpaez98EPzca/33ydyyBDnBVTLKIrC6XWn2fn5Tg7/chhj8eRkV19X2k9pT+9neksiJYQQNcCBA4lMmLCII0eSiY/P5uuvRzs7JCGuCkmmqpqiQM4pU/maT8tue4n7H1CgkancrJmKCRPsNBo71vq4QYMKhyhKt7R3b3O5/xdfEG6zFr2orNQTqSy/Zzmn/zltrovoFkHnezvTZmIbXDxdnBecEEKIcps3bw/337+CvDzTh8eLFx9ixox+REb6OTcwIa4CSaaqWtoeSzm0f7kvO3XayLxGlh6mpdPtbFS8dCn8+qvl+PTpCocn7EvcuZO/b73Vqk4SKcfZ+cVOVj28Cn2+Hq27lg63deCae68hLDrM2aEJIYQop9zcIh56aCVff73HXNehQyiLFk2QRErUGZJMVTVDnqXsW/7NhptMmAsjLMdtQ9pecl8DjBtnOd6xAyIjKxmkKCl53z6bRGrMmjVOiqb2Ob/9PCvuW4FiVGg8sDEj547Ev4m/s8MSQghRAUePJjNhwiL27080102d2okPPxyCu3v554YLUdNJMlXVjnxg+urZuNyXLFsGtPvefJz4ZKJto7fftpRfeAE6d65kgKKkrDNnWD15svk4rEcPBnz5pRMjql3y0/NZPHExilGh5ZiWTFw6UeZECSFEDfPTTwe4557lZGcXAuDhoePzz0dwyy3tnRyZEFefvUW2hSPFLjF9vThv6jK2bIHRo4HIjQBc32QwwZ6XLHseH29KoC567TUHBCoAlg8bZi43mzxZEikHUhSFZXctI/10On6N/Rj97WhJpIQQooZZufI4kycvMSdSrVsHs337PZJIiTpLkqmrpe1Ll22Sng49eyrwsuUN5uM9HrNtWHJ99FdfdUBwAmDHW2+Zy4Ht29OlZMIqrtj2T7dzeOlh1Do1E36egJuvm7NDEkIIUUGDBzdl0KAmANx6awe2bbub1q2DL3OVELWXDPOrSqu6WMpN7yq9XbHgYCDqT6u665teb91o+XJLuXFjePHFKwhQXJSXlMSxBQvMx9f/8IMTo6l94nbFsfqJ1QAMmjmIetfUc3JEQgghKkOjUbNgwQ2sWnWCKVPaywgDUedJz1RVSt1hKXs2vGxzvR7oPNd8nPlMpvUvqbw8GDXKchwT44AgBcCaO+80l695/nn54+BABZkFLJq4CEOhgZZjWtLt4W7ODkkIIUQ5FBYaeOKJP9m8OdaqPiTEk1tv7SB/K4VAkqmqU5RlKfdaWP7rWv0CQEPfhni7elvq//4bPDwsx+3bg/wSc4iDc+eSefIkAAFt2tD8ppucHFHtoSgKy6cuJy0mDd9IX0Z9PUr++AohRA1w9mwGfft+wwcf/MeNNy4mOTnX2SEJUS1JMlVVsk5YypETL9v8888BFPPxre2tl+bmhhusj3fvrnxswmzrSy+xd9Ys83Hfjz5yYjS1z865Ozm48CBqrZrxP43H3d/d2SEJIYS4jBUrjtGx4+ds3XoegMTEHLZsib3MVULUTZJMVZWEtRVqft99QP8Z5uPJ7SzLc3P8OGQV93Q98AAoCqjlW3eldr37LjFLlpiPr3nhBTzCZNNYR4nfG8+qR1YBMPCtgdTvXt/JEQkhhCiLXm/k2Wf/ZsSIH0lNNe2T2bixH5s338nIkS2cHJ0Q1ZMsQFFVYoqX1Nb5XLbp3r3FhX6WJc5bBZXY4Ld5c0v5rssvZCEu78TixRyZN898fMOGDbgFBDgxotqlIKuAxRMXYygw0Gx4M3o83sPZIQkhhCjD+fOZTJ68hA0bzprrxoxpyTffjMbPT1ZfFaI0kkxVBaMeMo+Yyl5NL9v8oYesj3s26GmZV1JQYDnRqhV07OigIOu2bTMsvYB9Zs2SRMqBFEVhxf0rSDmWgk99H8bMG4NKLfOkhBCiuvrrrxhuvnkpSUmmeVFarZp3372ORx/tLvNchbgMSaaqwvnfLeU+S0pvV2zDBqDHB+bjX2/81XKy5BLd27bJohMOsPUly55fre64gwbXXefEaGqfPd/sYf/3+1FpVIz7cRwegR6Xv0gIIYRTJCfnMnbsQnJyigBo0MCHhQvH06NHAydHJkTNIBNvqsLu6ZayV+Mym/72GxBwAgY/Ya4L9ize/O78eSixZDeeng4Msm7KiImxmifV9v77nRhN7ZN4MJGVD64EoP9r/WnY+/JbAgghhHCeoCAPZs0aAsCwYc3YvfteSaSEqADpmaoK2cUr+XlFXbbpiRNAr3fNx28MeMNyslkzS3n2bOmVcoBdM2eay4MXLkQnCarDFOYUsmjCIvR5epoObkrvp3s7OyQhhBDlcOedHQkJ8WT48OaoZVi2EBUiPVOOpliWN6fFI2U2NRrhyXf3Q+cvAFCh4rk+z1ka5OVZytKD4hD5SUkAqLRaAtu2dXI0tcsfD/5B8uFkvMK9GPvdWJknJYQQ1YzRqPDmmxuYPn21Vb1KpWLkyBaSSAlRCdIz5WixSy3lyEllNtV0/RweuM98/Fj3xywnp5cYKvjvv46Krk5LP36ctCOmhUFalxw+Ka7Y3u/2sufbPajUpnlSniHS4yeEENVJcnIuU6b8wqpVptEzPXs2YOzYVpe5SghxOZJMOdrG8ZayW1DZbUdaEqk2wW14f/D7pgNFgffes7Tr08eBAdZda0ssKx81YYITI6ldkg4nseL+FQD0e7kfjfo1cm5AQgghrGzeHMuNNy7m3LlMwDRr4MSJVCdHJUTtIMP8HM21OIHyjCyz2b6T8eby2Ab3cuCBA5aTMTGW8scfOzK6Oiv7/HnyU1IAcA0IwLNePSdHVDsU5RWxeOJiinKLaDywMX2ek8RfCCGqC0VR+OCDLfTr9605kQoO9mD16ilMn97LydEJUTtIz5SjqXWmr31/K7WJwQAdZncEb9Px4ts/s24wdaql/OCDDg6wblp2/fXmcq933y2jpaiIVY+sIvFAIp6hntyw4AbUGvl8RgghqoO0tDzuuOM3fvvtqLmub99IfvxxHPXqeTsxMiFqF3nn42h5cWWe1utBq1XA29Izpb70u7Bunemri4uDg6ubDCU2PtZ5eRHWo4cTo6k99v+4n11f7AIV3PD9DXiFeTk7JCGEEMCOHRfo3HmuVSL17LO9WbPmVkmkhHAw6ZlyJEO+paxxt9vk44+BYZbepmMPnLZu8PTTlvJ//zkutjrs1LJl5vLo1avLaCnKK+VYCr9PNW1O3feFvjQZ2MTJEQkhhADT0L7p0//i1Kl0AAIC3Jk/fyzDhjUr+0IhRKVIz5QjGQst5VLmTH37LWDUmY+bBZdol5ICJYegdezo2PjqqJhffjGXXXx9nRhJ7aDP17No4iIKswuJ7BdJvxn9nB2SEEKIYiqViu++G0NAgDvdu9dn9+57JZESogpJz5QjGYsu22TfPiDatNjEM72esT4ZVGL1vyVLHBhY3XVw7lxS9u4FILBDBydHUzv8+cSfJOxNwCPYg3E/jJN5UkII4WQGgxFNid/FDRr4sn797TRvHoiLi8aJkQlR+0ky5Ui7HreUVba/vNLSigsNNgOQry8xLDD1kiVKR41ycHB1zw9t2lgdRz9S9ibK4vIOLT7Ejtk7ABg7fyzeMvZeCCGcRlEUvvxyF598sp0NG+7Ax8fVfK5t2xAnRiZE3SEfKTvSqe8sZbVtnvrPP4BaD7o8AK5tdK3l5MyZlrLRCFrJc69E5unTVse9//c/Qrt1c04wtURqTCrL7jLNP+v1TC+iBkc5OSIhhKi7srMLufXWX5k69Xf27Uvg7ruXoSiKs8MSos6Rd+yOcmqBpdzkDrtNTpwAWlgWQ+ga0dVy8u23LWWVysHB1T2/Dx9uLo//7z9cvKUH5UroC/QsvnExBZkFNOjVgAGvDXB2SEIIUWcdOpTE+PE/c/hwsrkuONgDg0FBq5X3EEJcTZJMOYLRAFumWI7bzbDbzM0NuHGc+TjcO9xU2LbN0uihh6ogwLrlxOLF5rJ3o0aSSDnAX0/9RdzOONwD3Bn34zjUWunUFkIIZ5g/fy/33beC3FzTPG0vLxe+/HIkN97Y1smRCVE3STLlCMc+sZR7/VTqSn67Chaay94uJd7g33mnpTxrlqOjq1Oyzp5l2wxLMjti+XInRlM7HP7lMNs+MiX8Y74bg28DWRFRCCGutry8Ih5++A++/HK3ua5duxAWL55I8+aBToxMiLpNkilHOPCKpRx5Y6nNvs2ZZC6fefSM5cTBg6avvXvLEL8rkJeUxPKhQ83H0Y89hspmR2RREemn01l2p2loao8ne9B8eHMnRySEEHXPsWMpTJiwiH37Esx1d93VkY8/Hoq7u66MK4UQVU2SKUdwCYTCNAjtX67mQUk34O/ubzp46y3LiZEjqyC42k9RFHa9/TZHF1jmrQV37Ejru+92YlQ1n6HQwOJJi8lPzyeiWwQD3xzo7JCEEKJO+uOP4+ZEysNDx5w5w7n1VtnuQ4jqQJIpR8iPM31tMK7UJgt/SzOXR7u9bznx2muWssyXqpCU/fv5c9Ikm3qvBg0YVCKxEpWz5rk1nN96Hjc/N8b/NB6NTvYqEUIIZ3j44W6sW3eaY8dSWLRoAm3ayLLnQlQXkkxdKaMB9DmmsnfpQ6Ae2TYMXEzluTMbWk506gSbNsHDD4O7exUGWrtkxMTYTaQ6P/ccLW6+2QkR1S7Hfj/Glve3ADD6m9H4NfJzbkBCCFGHZGUV4O1t2TNKpVIxb94YNBo1Xl4uToxMCHEpmVBypS6ssJT92pXaLMHlP3NZrSrx375pk+lr796OjqzWOvr996wosamx1sOD63/4gZsOHpREygEyYjP49bZfAej2SDdajmnp3ICEEKIO+fXXIzRqNIs1a05a1fv6ukkiJUQ1JMnUlfp3tKXsHma3SXxmkrncL3We5cSFC5ayn5+DA6u9dr75prlcf+BAJm7fTlAHGTvuCIYiA0smLSEvNY9619Rj0LuDnB2SEELUCUVFBp544k/Gjl1IamoeN920lAsXspwdlhDiMmSY35U4MddSDu5VarMOL06FAFP57dtKzKuKiLCU+/RxcHC10w9t2pjL7R58kHb33+/EaGqfdS+tI3ZzLK4+roxfOB6Ni8yTEkKIqnb2bAY33riY//47Z67r1y9SeqKEqAEkmboSF/6wlPv+ZrfJ4kOLSQz41XzcvZOnqTB9uqWRp2fxjr6iLGlHj1odt73vPidFUjudWHWCTW+bhp2O+moU/k38nRyREELUfitXHmfKlF9ITc0DQKdT88EHg5k2rQsq2S5FiGpPkqkrce5X09dm08DV/oZ5ExZNMJfvCPzKcuK99yzl9HTHx1YLrZ482Vy+cfdu+SPjQJnnM/llyi8AXPPANbQe39rJEQkhRO2m1xt56aV1vPXWRnNdZKQvixZNoEuXiDKuFEJUJ5JMOYJP6av4uam8yVeyYP2LzFx0p6ny2DFLg1deAa18Gy5HURQMBQUABLRti8ZFhj44ilFvZOlNS8lNziUsOozB7w92dkhCCFGrxcVlMWnSEv7994y5btSoFnz77Wj8/WVlXyFqElmAorKStljKwfbnOymKYkqkAGIGEXix86pFC0ujZ56pmvhqEUVR+LFtW/NxjzfecGI0tc8/r/zDmX/P4OLlwvifx6N1k+ReCCGqUlZWIbt2mfao1GhUvPfeIH799UZJpISogSSZqqy/elrK/vZXktt+Ybu53MireHlpg8HSYPJkkB6Wy9r30UdWxz5Nmzopktrn5N8n2fDGBgBGfjGSwGb2h6sKIYRwnObNA/nyy5HUr+/Dv//ewRNP9JSh60LUUPIRdGUUpFrKTe8Blf2cdOryqebyyIHBpsL8+ZYGX3xRFdHVKrvff5/DX39tPr7p4EEnRlO7ZMdns/SWpaBAp3s60XZS28tfJIQQosISE3Pw9nbB3V1nrrvxxraMGNEcT0/5UFWImkx6pirjaImekm5zS222N2GvqZDnzzXXFFe+/76lgaen42OrZUomUgO++qqMlqIijAYjS29eSk5CDiHtQhgya4izQxJCiFrp33/PEB39GY8+usrmnCRSQtR8kkxVRtKGirVf8SnDhxeXDxwwfR040KEh1UaZp06Zyx2nTyese3cnRlO7bHhjA6fWnkLnqWPCzxPQlfi0VAghxJUzGhXeeWcjAwbMIy4um7lzd/Hjj/udHZYQwsFkmF9lZBQPNas3rNQmaXlploOE9gQEYL0E+rhxl14iSshNTOT3ESPMxy1uvtmJ0dQup/85zfpX1gMwfM5wgloGOTkiIYSoXVJScrn11l9ZufK4ua5//0b079/YiVEJIaqCJFOVkZ9g+hrUw+7pzIJMAt4NMB+76yNQqYC1ay2Nbr21CgOs+X7t399cbnXHHah10nPiCDmJOSy5aQmKUSH6jmg6TLG/eIoQQojK+e+/c0ycuIjY2EwAVCp44YW+zJjRD41GBgQJUdtIMnUl/NrZrV52dJnloNCTt2b4mcq7d1vqZb6UXYaCAhZ26mQ+Du/dm45PPunEiGoPxajwy5RfyI7LJrh1MEM/HurskIQQotZQFIVZs7Yyffpf6PVGAIKCPPj++xu4/npZhVaI2kqSqYrKOWsp+7Sy22TnhZ3msm5mNo8UFh+8/rrpa2Pp5i9NyUQKoP/nnzspktpn4zsbiVkdg9Zdy/ifx+MiE5+FEMIhcnIKmTLlF3755Yi5rnfvhvz00zgiInycGJkQoqpJf3NF5Vh2K8enud0m3i5+pkJ6JOZOlaeftjSYNKlKQqvpss6etTqetGePcwKphc5uPMu6F9cBMOyTYYS0CXFyREIIUXu4uWlJT883Hz/1VE/Wrr1VEikh6gBJpipqU3EipPMttcnKEytMhePDeOaZ4sp337U0ePPNqomthls+1DLsbNKePTJPykFyk3NZPGkxikGh/S3tib4j2tkhCSFEraLRqPnhh3G0bh3M8uWTeeedQeh0GmeHJYS4CmSYX0XlXTB9LcootcnOuO2mgmtxG6PRcvL776sosJqtKDvbXHYNCJBEykEUo8Kvt/1K1vksAlsEMnzOcFQqlbPDEkKIGi0rq4Bz5zJp1SrYXBcW5sX+/fejVsvvWCHqEumZqgh9rqXc9ze7TbbEbrEc/Psirq7AEcsYasaOrZrYarg/xo83l0evXu3ESGqXLR9s4fjK42hcNUz4eQIuXjJPSgghrsS+fQlcc80XDBnyPSkpuVbnJJESou6RZKoitk21lMMG2W3y2J+PWQ6SW5qSqQcftNS5u1dNbDWYobCQ7NhY87FW/o8c4tx/51jz7BoAhswaQmj7UCdHJIQQNZeiKHz99W66dfuSY8dSOHs2gwcf/MPZYQkhnEyG+VVE+j5LWWv/Df/W81tNBYPOkjetW1e1cdVgiqKw+amnzMeDFixwYjS1R15qHotvXIxRb6TNjW3oPLWzs0MSQogaKyenkGnTVjJv3l5zXceOYbz+ev8yrhJC1AWSTFWEscj0tcWjl2+75Hueew4YMMBS97//VUVUNdbBuXPZO2uWVV1wx45Oiqb2UBSF3+74jYyzGQREBTBy7kiZJyWEEJV0+HASEyYs4uDBJHPd/fdfwwcfDMbNTd5GCVHXyW+BinDxN30NsP8p/18xf1kOklvRogXwYoleqUcfrbLQaprkfftsEqlrZU8ph9g6aytHlx1F46Jh/M/jcfVxdXZIQghRI/3ww36mTl1OTo7pw1RPTx1ffDGSyZPbOTkyIUR1IclURSQXLy6h9bJ7+pFVj1gOklozfk6JXikZ6mclucQeUm0feID206Y5L5ha5Pz28/z1lCmpv/6D6wnvGO7kiIQQomZ69NFVzJq11Xzctm0IixZNoGXLICdGJYSobiSZKq+CFEtZZX/viMPJh02F40OZdKMa1U8lEqg+faowuJplx1tvcax4blRAmzaSSDlIfnq+aZ5UkZFW41rR5YEuzg5JCCFqrFatLEnTHXdE88knw/DwkG07hBDWJJkqr9Ml9oeqN8zmtKIoloNt0/DL+91yfP48aGTzPoA/b7qJlL2WCbwtb73VidHUHoqisOzuZaSfSsevsR+jvhwl86SEEOIKTJ3amR07LtCzZwPuuEPm8woh7JNkqrx2lhjCp7ZNjFbHlNgb6dQA5ug9LMf16lVhYDXH8YULrRKp/nPnEt6rlxMjqj22z97O4SWHUevUjF84Hjc/N2eHJIQQNUZBgZ5Vq04wenRLc51KpeKLL0Y5MSohRE0g+0yVR36ypRxsf7jeS/+8ZC6H6jMsJ6KiqiqqGmf7q6+ay0OXLJFEykHidsWx+nFTMj/o3UFEdIlwckRCCFFznDqVRu/e3zBmzEKWLTvq7HCEEDWMJFPlkfKfpTzgL7tNsguzTYV8X+5njuXEoUNVGFjNoM/P54c2bczHre+6C/+WLcu4QpRXQWYBiyYuwlBooMXoFnR7pJuzQxJCiBpj2bKjdOo0lx07LgBw772/k5+vd3JUQoiaRIb5lUdurKWssb/M9KGk4qTpj4+YwW2WEzqZrLq4m/Ub/HYPPuikSGoXRVFYPnU5aTFp+Db0ZfTXo2WelBBClENRkYHnnlvDe+9tMdc1berPokUTZO8oIUSFyG+M8tjzrOmrdzO7pxcfWmwuv3NqpeXEiy9WZVQ1QvLevRj1lk/5bty9G42LixMjqj12fbGLgwsPotaqGffTONwD3J0dkhBCVHvnzmVy442L2bzZ8kHpuHGt+OqrUfj6ynxTIUTFSDJVHkXFc6A09n/JPvP3M+byU5kLLSdefrkKg6oZVt90k7k8Yds2SaQcJGFfAqseWQXAgDcH0KBHAydHJIQQ1d+qVSe45ZalpKTkAaDTqXn//et58MGu0rP/f/buO76p6n3g+CfpHkCBQluG7D2ktAxB9t6zgCAoKFMQUBFFvyzBvUDkB6iAClZoWbJREUT2KEv2HoVCN51pk/z+SHvbWFahyW2T5/168crJyc29T2ps8+Sc8xwhxBORZOpR0u5ltevMvO8hF2MuAlD4YiBwyNS5eDFo7XtJmiEtTWmXadMGJw8PFaOxHboEHSH9QkhPSadK5yo0ebOJ2iEJIUS+9/33RxgxYj2ZO5mUK1eElSuDaNhQivYIIZ6cfX/afxxp2Srzle2Z4+F9N7KKU9TY1yHrgWwjMvbq13r1lHbTzz9XLxAbYjQa2Th6I1FnoyhUuhA9f+yJRivfpgohxKO0bVsRr4xtI7p2rcqRIyMlkRJCPDUZmXqUzK+wtPcvJLH69GqlXed8xlSrEiXA5f6FKuxBwo0b/Nahg1mfTO/LG0eXHOX4suNoHDT0/bUv7t7uj36SEEIIypf34scfe3LmTCRvvtkErXwRJYTIAzIy9Si7+5tuDWn3fTgyybQHlXNKKdLISKDi4u57rD3YPWlSjkQqaP9+laKxLXf+vcOmsaYCJ60+aMUzzz+jckRCCJE/GQxGvvlmPwkJOrP+bt2qMWlSU0mkhBB5RpKpR4nc+9CHlxxdAoDuagOWMtTU+fzzlo4qX7r+++9c3ZRVzbBojRoM/PdfnDw9VYzKNugSdYT2CyU9OZ1K7Svx/GT7fI8JIcSj3L2bSKdOy3n99S2MHLkBY+YMEyGEsABJph5XvU8e/vidqlntpCTLxpJP7ZowQWl337qVTqGhDz5Y5MrmcZu5e+ounn6e9Pq5l6yTEkKI+/jnn2v4+y9k2zZTYahffz1JWNhtlaMSQtgySaYeRp+S1S7VJcfD91KzKv3VPZ0tmfrxR0tGle+5envjWaaM2mHYjGM/H+PokqNotBr6/NIHj5JSFVEIIbIzGIx89tluWrZcys2bpr/NPj4e/P77YOrX91M5OiGELZMCFA9z5++s9n027O0b0ldpDwi/mPVA1ao5jrV1SRERSrvlggUqRmJbIs9EsnH0RgBaTGtB+Zbl1Q1ICCHymejoZF5+eS3r159T+lq2LE9wcB98fWWauRDCsiSZepiUO1lth5zV6LZd3Ka0oylmari5WTqqfGlt69ZKu1iNGipGYjvSktMI6RdCWmIaFVpXoNl7zdQOSQgh8pUDB27Sr18IV69mFX56//1mTJvWEkdHmXwjhLA8SaYeJjJjD6mSzXM8dOTWkaw7G/6P6hw0tYOCrBBY/nIuOFjtEGzSlglbuHPiDh4lPei9vDdaB/lgIIQQmQ4fDuf55xeTlmYAoHhxN5Yt603HjpVVjkwIYU8kmXoYl4zRpqTwHA99c+CbrDtHXqU9s03tmzetEFj+cGP7dv4eN86sr+/eh1c/FI/n5K8nObLoCGig9/LeeMpUFSGEMOPv70eHDpXZsOEcTZqU5ddf+1C2bBG1wxJC2BlJph7mXsY6qFIdczy09OhSALzuNSHJoKcsN0wP2MEUt/jLl9nQtWuO/uc++QTnwoVViMi2RJ2PYv3w9QA0e68ZFdtWVDkiIYTIf7RaDT/+2JP58w8yeXJTnJwc1A5JCGGHJJl6mNSMNVOpUWbdibpEpR17vCmDWZH14MSJ1ohMFcl377KmZcsc/c906ECTTz5B6+Rk/aBsTHpKOqH9QtEl6CjXvBwtp7VUOyQhhFCd0Whk0aLDVKvmTctshXiKFXPj/fdzTsUXQghrkWTqYTKr+RUyr853+NbhrDt/fogni7LuV7TdUYQN3bvn6Ou7Zw/ORWRaRV7Z+uZWbh+9jbu3O71/6Y1WFlALIexcQoKOkSM38MsvJ/D19SQsbKRU6RNC5BvySe1hnDKSBKesqWtGo5EWS1tkHWNwpCm7Te327a0YnHXpU1NJi49X7r9w4gQD//1XEqk8dCr0FIfmHwKg18+9KFxapkwKIezbyZN3aNDgO3755QQAt28nsGbNaZWjEkKILDIy9TCpd023XrWVrn/v/qu0XdN9SQFukbEhYGqqFYOzrpPZ9o7qsm4dGq3k4Xkp5lIMv73yGwBNJzelslSjEkLYuR9/PMro0RtJTk4HoFAhZ374oTtBQbVUjkwIIbJIMvUgRkNW27OS0oxOjlbahRfdIgUIqBgDl4CGDa0XnxXd2rOHfxdlTWUsUlk+6Oel9NR0QvuHkhqfStkmZWn1QSu1QxJCCNUkJaUxbtwmFi8+qvQ9+6wPISFBVKlSXL3AhBDiPiSZepDEq1lt99JK873t7wHg5erFnYz6FK0uLTY1dDprRWc1v9SuDUajcv/ZCRPUC8ZG/TH5D8IPheNWzI0+v/bBQSpSCSHs1NmzkfTtG8LJk3eUvhEj6vP11x1xc5MiR0KI/EeSqQdJuJTVdnBVmnqDHoDYlFgAXuH7rOPq1rVGZFYTsX+/WSJVvnt3ag0frmJEtufM2jPsn7MfgJ4/9qSI7JEihLBTyclptGz5I7dvJwDg7u7EwoVdefFF2/rbKoSwLbLw5UH091//tP+m6YNvf5+pAPRiTdaDL75o8bCsJTU2lj+HDVPu99m9myYffaRiRLYn9kos64auA+C5N5+jateqj3iGEELYLjc3Jz77rB0AtWqV4NCh4ZJICSHyPRmZepCLGSNOReubdRsy1lLdumIaQejCJtMDbduCs7PVwrO0Xdmm89UcPhwXLy/VYrFF+jQ9oQNCSYlNoXTD0rT5sI3aIQkhhOpefLEuer2Bvn1r4uFhO39ThRC2S0amHsTZy3Qbc+S+D8cf6kpJIrI6evWyfExWFP1vVtXCerJOKs/9OeVPbu6/iauXK31X9MXBWdZJCSHsy+rVp3nnnT9y9L/0Uj1JpIQQBYaMTD3IDdP0K2pPVbr23dintI/+48PbZJULZ/Roa0VmcXqdjvSkJADqjB2rcjS259zGc+z9fC8APZb0wKu8l7oBCSGEFel0et5++3fmZKwXrVfPlwEDaj/iWUIIkT/JyNSD6KJzdD33w3NZd1KLUJfjWfc1GisEZR0r/P2Vtl/TpipGYnvirsexdshaABq+3pDqPaurG5AQQljR1auxNGu2REmkAP7889JDniGEEPmbjEzdT3pSVtu3XY6HXQ3FSQGiKWbqqF8/xzEF1e19+8zue9tYhUI16dP0rHphFcnRyfgF+NHu05zvLSGEsFUbNpxjyJA1xMSkAODs7MDXX3dg1KhAlSMTQognJ8nU/RiyVfLzbgzAwZsHla6m53fwJ9DUYT/ogU6drBufBW1/5RWl/cLJkypGYnt2TNvB9d3XcSnsQt8VfXF0kf/9hBC2Lz3dwPvvb+eTT3YrfRUqeBESEkRAQCkVIxNCiKcnn+buJ+Fytjum6Xtht8OUnmN/1AKgvj4jwbpzB1uwvksXpe3q7Y3GhqYuqu3C1gv889E/AHT7vhvFKhVTOSIhhLC8mzfjeeGFVezadU3p69mzOkuW9MDLy/UhzxRCiIJB1kzdT1TWXG60piprmoykqnu17kTe/U+S0abgl7VOS0jg3pUryv0ev/+uXjA25l74PdYMNu1HFjg6kFpBtVSOSAghrGP8+C1KIuXoqOWrrzqwenU/SaSEEDZDRqbuR5vxS97BTenKHJm6E2FKpOqRNVJFYMGf731j+3al3WvHDhxsaM8sNRnSDawauIqku0n41vOlw5cd1A5JCCGsZu7cTuzadQ0XFwdWrgyiceMyaockhBB5KtfJVHR0NL/99hs3b95k/PjxHDx4kFatWlkiNvXc3WW6LdlC6XJ2MCUX+86fBaADW7OOr1jRaqFZyr+LFgHg4OaGW4kSKkdjO3bO3MnVnVdx9nSm78q+OLrK9xdCCNtlNBrNpoiXKlWIjRsHUqGCF8WLu6sYmRBCWEaupvn9+++/dOzYkS1bthAaGkpMTAzjx49n1apVlopPHffOm26TbypdDpqMTVXPdQOgQdnbpvuVKtlEWfT4y6Z1Yk7u8scur1z64xJ/z/obgK6LulK8SnGVIxJCCMvZseMKzz+/hJiYZLP+wMBSkkgJIWxWrpKpjz76iHfeeYdff/0VR0dHypYty7fffssPP/xgqfjUcddUKIDCNXM+ZjT9yPpcn2O6b2Olw+u89praIdiEhNsJrH5xNRih/vD61HmhjtohCSGERRgMRj78cBdt2vzEnj3XGTp0HUajUe2whBDCKnKVTJ07d44ePXoAKMP4zZo1IyIiIu8jyw/82ivN5PSsb9oaNsx2jJOTFQOyjOPz5iltvyZNVIzENhj0Bla/uJrEiERK1i5Jx687qh2SEEJYRGRkEl26/MJ7723HYDAlUImJaSQmpqkcmRBCWEeukqlixYpx6ZL5TuWXLl3C29s7T4NSVVpCVtsrazThj0t/mBoOOg4ezHb8G29YJy4LMaSlcfL//k+571m2rIrR2IbdH+3m8p+XcXJ3ou/Kvji5F/yEWwgh/mvPnuv4+y9ky5YLgGnG+4wZLdmyZRCenlLESAhhH3KVTA0cOJCRI0eycuVK0tPT2bRpE+PHj6d///6Wis/6Do7OahcLUJpVilcxNfROjOqdbV+pcuWsFFjeM+j1/FqvnnK/ZrYNe8WTiTocxd8zTeukuvxfF0rUkGIeQgjbYjQa+eKLPbRosZQbN+IBKFnSg99/H8zUqS1wcJBdV4QQ9iNXpcWGDBmCg4MDP/74IwaDgblz59KvXz+GDh1qqfis78qyrLYm6w9CQuaAVWQNZhZ6L+sYX1/rxGUBCdeyNlF09famXgEfZVNb4p1Ejrx3BKPBSL2X6/HskGfVDkkIIfJUTEwyQ4euY926s0pf8+blCA7uQ6lShVSMTAgh1JGrZOrYsWMMGjSIQYMGmfX//fffNG/ePE8DU42jB6QnQrM1Zt1/39qktL3XfG/tqCwiPtsmvb137lQvEBtgNBhZ9/I6UiNT8a7hTad5ndQOSQgh8tzatWfMEql3332emTNb4egoo1FCCPuUq99+9xuBSkhIYPz48bm6aFRUFGPGjCEwMJBGjRoxe/Zs0tPT73vsgQMHCAoKwt/fnxYtWrBw4cJcXStXDOmmRAqgSFYlvzR91kLaMtpiWce//LLlYrGCv8eOVTsEm7H7091c2nYJrYuW3sG9cfaQ9QJCCNvz8sv16N+/FsWKubFp00A+/LCNJFJCCLv2yJGpq1ev0qVLF/R6PUajkRo1auQ4pn79+rm66IQJE/Dx8WHXrl1ERkYyevRoli5dyquvvmp23MWLFxkxYgTTpk2jZ8+enD17lpdeeoly5crRsaMFKqSlRma1PSvc95DXj/2edWfBgryPQQVaG6hIqKZr/1xj+/vbAag9qTYla5dUOSIhhMgbaWl6s/sajYZFi7oRF5dC2bJFVIpKCCHyj0cmU+XKlSMkJIT4+HhGjBjBd999Z/a4i4sLVatWfewLXr16lQMHDvD333/j5uZG2bJlGTNmDJ999lmOZOqXX36hTZs29OrVC4Dq1avz66+/4unp+djXy5WEbJUKtVkJxtW4q0q7YnktXMy44+JimTis4PTSpUq7Y0iIeoEUcElRSax6YRVGvZHaA2tTtodUQxRC2IZjx27Tr18Ir71WmWy1iihc2IXChQvu3z8hhMhLj7VmKnM0asOGDZR9ytLZ58+fx8vLCx8fH6WvUqVKhIeHEx8fT+HChZX+48eP06RJE9544w12795NsWLFePnll5+oeqBer0ev1z/0GE30UWXeY/Zjr8deV9otEkwl0g2jR2N8xPnys7DPPlPanuXLP/JnI3IyGoysGbKG+BvxFKtajPZz23Puyjn5WQqLy3yPyXtNWILRaOSHH8IYP34rqal6pk4No3PnQCpUKPboJwvxhOT3mrCWvH6P5aoAhaenJ3PnziUiIgKDwQBAWloa586d47fffnuscyQmJuLm5mbWl3k/KSnJLJmKi4vjp59+4quvvuLTTz8lLCyMkSNHUqRIkVxP8zt16tQjjykbsYPMCVpHjx5V+vfe3Ku0vSNM54m6dYtr2Y4pSFJv3lTa3n36cOz4cRWjKbgu/nyRC5suoHXWUnt6bc5dOQfAiRMnVI5M2At5r4m8lpSUzkcfnWDz5qy/E6VKuXP69Bni4txVjEzYC/m9JgqaXCVT7777LleuXKFYsWIkJibi5+fHP//8k6O638O4u7uTnJxs1pd538PDw6zf2dmZNm3a0LJlSwAaNGhAjx492Lx5c66TqZo1a+Ls/PCiANrfdgNgLFyLetnmNLx96CMAqp2qAZwGoNiQIRTLPu+hADn6559Ku9V776F1zNXbQAA39t1g07emCo8dvu5AQL8A9Ho9J06coE6dOjg4OKgcobBl8l4TlvDvv3cZOXIVp09nrR8eNao+Q4b4EBBQT95rwqLk95qwFp1O91iDLI8rV5+iDx48yKZNm4iIiGDRokXMmzePdevWsWHDhsc+R5UqVYiNjSUyMhJvb2/AVGjC19eXQoXM96ioVKkSOp3OrC+zEEZuOTg4PPp/zuRwADQlnzc79ljkAQDq6K5kna9nT9N27wWQS8boX9GaNXEqwOu+1JIck8yaQWswpBuo1a8WDUY1QJPtvfBY7zUh8oC810Re+emnY4wevZGkJFP1Wk9PZ77/vht9+9bg6NGj8l4TViPvNWFpef3+ylU9U0dHR3x8fChfvjxnz5r2mejSpUuusrvy5csTEBDAhx9+SEJCAtevX2f+/Pn07ds3x7EDBgzgzz//ZN26dRiNRg4ePMj69evp0aNHbsJ+PEZDVtuntdlDhR1Mk/+aHW9q6ihZssAmUpC1v1TxWrXUDaQAMhqNrBu6jrircRStVJRu33UzS6SEEKIgSU5O49VXf+Oll9YqiVTduj4cPjyC/v1rqxydEELkf7lKpkqXLs3JkycpXLgwiYmJREdHk5SUREpKSq4uOnfuXNLT02nTpg39+vWjWbNmjBkzBgB/f39l/dVzzz3H/Pnz+emnnwgICODdd99l8uTJtGnTJlfXeyxxp7PaJVuYPXT5iinRqpGYsQfVf6YjFjRX1q8HICUqSuVICp79c/dzdt1ZHJwdCFoZhItUtBJCFGC3bycQGpr1heirr/qzb98rVK1aXMWohBCi4MjVNL+BAwcyePBgNm7cSNeuXXnppZdwdHSkQYMGubqot7c3c+fOve9jYWFhZvdbtGhBixYt7ntsnjJmq+zhllVp8M5dPfiZYmoXkVGIokwZy8djIdmnSHoU4NehhpsHb/L7JNM+Y+2/aI9ffT+VIxJCiKdToUJRlizpwYsvruH//q8LQ4Y8q3ZIQghRoOQqmerbty9Vq1bF29ubSZMmsWTJEhITE3nllVcsFZ/1RJg2XcXVfMPVPu+vhVL/ObZtW6uEZAkxZ84o7bpjx6oYScGSEptCaP9QDGkGavSuQYPXcvcFghBC5Aepqeno9Ubc3bP2UuzVqwaXLz9DyZIFe9aFEEKoIVfT/ADq1q2Ls7MzTk5OjBgxgokTJ7J3795HPzG/C5tkuk25Y96dvizrTtGipttcVhLMT8L//ltpOxXw6YrWYjQaWT98PbGXY/Eq70X3H7rLOikhRIFz6VIMTZsuZvTojTkKOUkiJYQQT+axkqn4+HgmT55Mt27d+OKLL5Q9ppKSkpgyZQoTJkywZIzW4VHedFu4ull3EYfSpofTy0JMTMYxhSmojmdMr3QrWfIRR4pMh/7vEKdCT6F10tJ3RV9cvVzVDkkIIXJl7doz1K+/kMOHb/HTT8dYvDjs0U8SQgjxSI81zW/atGmcPHmStm3bsnHjRkqWLEmHDh0YNmwYd+/eZc6cOZaO0/KcMhKkeh+bdYe7mNbI9PToD3xu6tTmekAvXzCkpSltn4YNVYyk4LgVdoutE7cC0PaTtpRuWFrliIQQ4vGlpel5550/+PLLfUpf5crFCAj47/x1IYQQT+Kxkql9+/axbNkyKlWqRJcuXZg5cybBwcEUK1aMH374AR8fn0efpKDQZlVnS0wE4suA9zlq3MpW/r1yZevHlQeyJ1MNpk5VMZKCITU+ldB+oeh1eqp1r0bjCY3VDkkIIR7btWtx9O8fyr59N5S+oKCafP99dwpLJVIhhMgTjzXEkpKSQqVKlQCoXbs2J0+epEaNGixdutS2Eqn7cTAlIK/uOG+67+RUIEem0hITWZmt6qLWyekhRwuj0ciGkRuIvhBNkWeK0GNJD1knJYQoMDZtOo+//0IlkXJy0jJvXidWrOgriZQQQuShxxqZ+u+HSGdnZ/73v//h6JirYoD5W8yRHF0GA1BuFwA+xzOSKb0+x3H5XfLdu6xp2dKsz8HZWZ1gCogj3x/h5K8n0Tho6PNrH9yKuakdkhBCPJJeb+B///uLjz76R+krX96LlSv70qCBTFMWQoi89kTZkLOzM15eXnkcisoc3ECfDE5FlK41a02FNoonZjtu+nTrxvWUjEZjjkRqwLFj6gRTQEQcj2DL61sAaPNhG8o+V1bliIQQ4vFoNBrCwm4r97t3r8bSpT0oWlS+EBJCCEt4rGTKaDRy69YtpZSqwWAwuw9QqlQBX8yqTzbdumVtxJquMfVVj8x23DvvWDGop7fztdeUtouXF31271YxmvxPl6AjpF8I6SnpVO5UmSZvNVE7JCGEeGxarYaff+5Fw4bf8dprDXjjjedkirIQQljQYyVTycnJtG7dWrlvNBqV+0ajEY1Gw+nTpy0ToTWkRmW1Hd1zPPzDb9nuFLC1RuE7dyrt3rt2qRhJ/mc0Gtk4ZiNRZ6MoVLoQvX7qhUYrH0KEEPmXXm/g2rU4KlQoqvR5e7tz6tRruLra0FR8IYTIpx7rN+2ff/5p6TjUde9iVts1a/+l5CTT7W1PqBZFgXMsY08pgIbTp6MpgIUzrOVe+D1+f/t3Tiw/YVonFdwHd++cibUQQuQXd+4kMmjQak6duktY2EizjXclkRJCCOt4rN+2pUvb+KLVtLj7dk+bmQbDocXVjI5Zs6wXUx74d+FCpV2pTx8VI8m/9Do9+77ex98f/I0uQQcaaPdZO8o1K6d2aEII8UB//32VAQNCuXUrAYCXXlrLpk0DZUqfEEJYmXx1lZ3Xs2Z3o3xX8srhbB3Nmlk3nqeQfU+pcp07y6jUfVzYcoEt47cQdc407Fi6UWk6fdOJ0lLxSgiRTxkMRj77bDfvvbcdvd60btnX15N33mkqiZQQQqhAkikAjDl60tMB36MsWp+ts3lzq0X0NG7v28f2V15R7tefPFnFaPKf2CuxbBm/hbO/nQXAo6QHbT9py7NDnpU1UkKIfCsqKokhQ9ayadN5pa9NmwosX94bHx9PFSMTQgj7JckUwLl5pltjutJ1+TKQ5J21q/GMGdaO6ollT6QcPTxw8/ZWMZr8JeF2Aj889wMJtxPQOmppOK4hLaa1wLWIq9qhCSHEA+3bd4N+/UK4fj0eAI0Gpk5twf/+1xwHB5l5IIQQanmiZCouLo7r169Ts2ZN0tPTcS7oG8DGnzHdxv2rdK1YAa3jzmUd88ILVg7qydzMVr2vdKtWtJg3T8Vo8g9DuoHDiw6z/f3tpMSk4O7tzss7X6ZEzRJqhyaEEA81f/5Bxo/fQnq6ae/DEiXcWb68N+3aVVI5MiGEELn6OisxMZE333yTRo0a8eKLL3LlyhXatWvHpUuXLBWfddzLmDJRZYzSdfAg+JTOVhO9ShUrB5V7+tRUdo7Jeg3Ns1Xzs2fXdl9jUcAiNr22iZSYFErWLsmLW1+UREoIUSC4uzspidTzzz9DWNhISaSEECKfyFUy9emnn5KUlMTmzZtxcnKibNmytGrVitmzZ1sqPutw9TXdlmyhdMXFAU6mTXtP1PVVIajcW1G/vtKu1KeP3RedSLybyLqh61jy/BIijkfgVsyNzt92ZmTYSPzq+z36BEIIkQ+8/HI9hg2rx+TJTfnrr5coXbqw2iEJIYTIkKtpfn/99Rfr16+nSJEiaDQanJyceOedd2heQAoz3JfRCCm3Te1ClZXuiOgkFpw0tct45v8P3pd/+83sfqOZM1WKRH0GvYEj3x3hzyl/khKTAoD/q/60/ait7B0lhMjXjEYj//xzjWb/2Z7h+++7S7U+IYTIh3KVTBkMBmV9lNFozNFXIKUnZrXdn1Gat5+ZTfUTprbX4VNWDir39r77rtLuHxamYiTqCj8UzsbRGwk/FA6Ar78vXeZ3oUzjMipHJoQQDxcfn8rw4etZufJfQkKC6Nu3pvKYJFJCCJE/5WoeWOPGjZk5cybJycnKL/avv/6ahg0bWiQ4q3PM2j3eT3dUaWuyFXXIj65t3aq067z2Gg4FObl9QskxyWwcs5HvGn5H+KFwXAq70OmbTgw/OFwSKSFEvnfs2G0CAxexcqWpENIrr/xGVFSSylEJIYR4lFyNTL377ruMHj2aBg0aoNfr8ff3p3z58ixYsMBS8VlBzj2mkpKg9e2YrI5GjawYT+4k3bnDP2+8odyv+eqrKkZjfUajkWM/HeP3Sb+TdNf0waPui3Vp91k7PH1l3xUhRP5mNBpZvDiMsWM3k5Ji2p6jcGEXlizpQfHiMi1ZCCHyu1wlU8WLF2fFihWcOHGCmzdv4uvrS926dXFwcLBUfJZ3M9uuvFonAM6dA3dDqkoB5c6BadOUdrUXX7SrUamIExFsGrOJa/9cA6BEzRJ0/rYz5VuWVzcwIYR4DImJOsaM2cRPPx1T+vz9fQkJCaJSpWIqRiaEEOJx5SqZGjVqFH379qVVq1bUrVvXUjFZ152/s9pa048jPh7SyhyBf+H089WpoVJojyP8b1P8ju7uBGRbN2XLjEYjf777J3s+24PRYMTJw4kW01rQeEJjHJwKcGIvhLAbp0/fpW/fEE6duqv0jR4dyJdfdsDV9Ym2gBRCCKGCXK2ZqlSpEjNnzqRFixZ89tlnXL582VJxWY+Lt+m2cDWla/5CndLWeHj89xn5RsLNm0r7uQ8/VDES60mOTmbTa5vY/clujAYjNfvWZOyZsTSd1FQSKSFEgbB16wUCA79TEilPT2eCg/swf34XSaSEEKKAydVv7UmTJvHmm2+ya9cu1q5dS8+ePalduzZBQUH07NnTQiFaiW97pbmxZAtmZuxDXLlY5Qc8QX1X1mdNUSzdurWKkVhewu0E9n61l0PzD6FLMCW7Xf6vC4GjAlWOTAghcqdWrZK4uzuRlJRGnTolCQkJolo1b7XDEkII8QRy/RWYVqulRYsWtGjRgp07dzJjxgzefffdgptM3dlhdvdG/A0SvPZR6p7pvmNktPVjegxpiYkc/+YbABw9PNAW5HVrD6FL0LFz5k4OfHOA9IzF2T51fWj1QSuqda/2iGcLIUT+U6ZMYZYv782KFSf55pvOuLs7qR2SEEKIJ5TrZOratWusXbuW3377jeTkZHr06EFQUJAlYrMOl5Km22TTlLl9N/YB0CZjZIoqVVQI6tFCspWj97GV0vT/cXrNaTaP28y9m6bMtkzjMjR7rxlVulSRPVeEEAXGunVnaNmyPEWKuCp97dtXon37SipGJYQQIi/kKpkaMGAAJ06coHHjxkyaNIk2bdrg6FjA53drMpaN+bQB4OSdkwB4J2c87uOjQlAPd3vfPrP7zTNGqGxF4p1ENo7eyOnVpwHwquBFp7mdJIkSQhQoqanpvPXWNubNO0ifPjUICQmS32FCCGFjcpUJNWnShC+//JJSpUpZKh7VuTi40PtUto5hw1SL5UH+GjlSafcPC7O5P86rX1zNpd8voXXU0uTtJjR/vzlObjINRghRcFy+HEO/fqEcOhQOwKpVp9m8+QKdO+fP2Q5CCCGezGMlU7dv38bX15e+ffsCEB4enuOYAptgXV9ldvdkxGkKZ99iqkwZ68bzCNH//osx3bR2qHTLlja3r1RSVBKX/zRViRy2exilG5ZWOSIhhMid3347y0svrSU2NgUAFxcH5szpSKdO+begkRBCiCfzWMlU586dOXLkCK1bt0aj0WA0GpXRkMz26dOnLRqoxRkNAOzcnUr3NFNXWvvO5LfxkC39+intBlOnqhiJZVzYcgGjwUjJOiUlkRJCFChpaXqmTPmTzz/fq/RVqlSUkJAg/P39VIxMCCGEpTxWMrVx40YA/vzzT4sGY3X6rP2kKBaATgc3L7vTIGPgzUmXpE5cD3A3LExpOxUqhHs+XM/1tM5vPA9A1a5VVY5ECCEe340b8fTvH8qePdeVvj59avDDD93NCk8IIYSwLY+1aa+fn+kbtVmzZlG6dOkc/yZPnmzRIC0mKeuPHsUbEhlpasZm/t0zGq0e0sMcmDFDaXffskXFSCzDkG7gwuYLAFTpIusKhBAFw5UrsdSrt0BJpJyctMyd25GQkCBJpIQQwsY9cmTqxo0brF27FoB//vmHefPmmT2ekJDA2bNnLRKc1Th6gNaBffuA2r8ycV1Gf926akZlJiU6mrjzplEb1+LFcfHyUjcgC7i+9zopsSm4FXOjTOP8tVZNCCEepFy5IrRoUZ7Vq09TrlwRVq4MoqFMUxZCCLvwyGSqVKlSnD9/nujoaPR6Pfv37zd73MXFhWnTplksQOswDdAtWWqEgBTOFodqUYDBoG5Y2axu1kxpt/ruOxUjsZzMKX6VO1ZG6/BYg6ZCCKE6jUbD4sXd8fHxYNas1hQr5qZ2SEIIIazkkcmUVqtlzpw5ALz//vvMmjXL4kGpJaLW+wAok/v691ctluyS7941u1+0WjWVIrGszGRKpvgJIfKz7dsvYzQaadOmotJXpIgr8+d3UTEqIYQQashVafQxY8bctyw6FODS6NkcdP1Q7RByMKSlsaZlS+V+u59/Vi8YC4q7Fsedk3fQaDVU7ijlg4UQ+Y/BYGT27L+ZPn0nxYq5cfToSEqXLqx2WEIIIVT0xKXRs7OF0ugGY9aUPndKAnfUCyab3W+/rbR9mzShRP36KkZjOec2ngOgzHNlcJMpMkKIfObu3URefHEN27ZdBCAyMolvvjnAxx+3VTkyIYQQarLv0uhGvdIMv52utJ+Jyh+JFMD1bduUdmsbXSsFcH6DlEQXQuRP//xzjQEDQrl58x4AWq2GGTNaMmVKs4c/UQghhM17rGQqszR66dKliYyMxNvbG51OR2hoKMWKFaNjx44WDdJi4s+YbtPvcfzKTQAKp2R7vEgR68eUze19+5R2k88+UzESy0pLSuPy9suArJcSQuQfBoORL77Yw7vv/oleb5qR4ePjwS+/9KF16woqRyeEECI/eKxkKlNISAizZ8/m6NGjfPbZZ2zatAmNRsOlS5cYM2aMpWK0nPiMku4aB5LSTd84Nsm29RR16lg/pmz2ZJviV65TJxUjsazLf10mPSWdwmULU7J2SbXDEUIIoqOTefnltaxff07pa9myPMHBffD19VQxMiGEEPlJrupPL1u2jG+//Ra9Xs/q1av55ptvCA4OZuXKlZaKz7I0GtOt1knpckv0yvm4SlKiogAoUqkSGpVjsaTsVfxs+XUKIQoGg8FIq1Y/KomURgPvv9+M338fLImUEEIIM7lKpm7dukXTpk05duwYjo6O1K9fn7JlyxIfH2+p+Cws44N72b5KT/HkjEIUzz2nQjxZshf5qDpwoIqRWJbRaFSSqapdZL2UEEJ9Wq2G9983rYfy9nZn8+ZBfPBBaxwdZf87IYQQ5nI1za9IkSJcvXqVrVu30rBhQwD27dtHiRIlLBKcxUXuzWhkjYZUiMsoSnH7tvXjyebcL78o7TJt2qgYiWXd/fcucdficHR1pIKsQRBC5BNBQbX45ptEevasTpkyUv5cCCHE/eUqmRo6dCjdunUD4Oeff+bw4cOMHDmSadOmWSQ4i3PKKDCReAlcTc17zpmjVWXViQnQxcdz+MOsPa9cixdXLRZLO7fBNI2mQusKOLk7PeJoIYTIe2Fht1i79gwzZrQy6x87tqFKEQkhhCgocpVMDRw4kGbNmuHo6Iifnx/R0dEsX76c2rVrWyo+y9JkTNnw68jnIT+aJj1qMqb5VaqkWljZN+lt/8svaLS2O7Uk+3opIYSwJqPRyMKFh5kwYQupqXoqVizKSy/VUzssIYQQBUiukikAJycn1q9fz82bNylRogRdu3a1RFxWpkGrKwKu4KBNUjUSo9GIPjVVue/97LMqRmNZydHJXN9jKp8oyZQQwpru3Utl5MgNBAefVPqWLDnKkCHPSiEcIYQQjy1XQx4nTpygS5cubNu2jbi4OLZv306PHj04fPiwpeKzrFtZG+LuzVg+NehkxpS6tDQVAoLLv/2mtNv++KMqMVjLha0XMBqMlKhVAq9yXmqHI4SwEydORNCgwXdmidS4cQ3ZuvVFSaSEEELkSq5Gpj777DPGjx/PkCFDlL4ff/yRzz//nODg4DwPzuKSrpluUyPx9i5KpBFq3DWVI0elCoX7pkxR2iUCAlSJwVpkip8QwtqWLj3KmDEbSU5OB6BQIWd++KE7QUG1VI5MCCFEQZSrkamzZ88y8D9lugcOHMi5c+ce8Ix8zsXbdFu6Cw4OUCIx22MqbEJsyDYaVmXAAJv+htSgN3BhywVASqILISwvKSmNYcPWMXToOiWRqlfPl8OHR0giJYQQ4onlKplyc3Pj1q1bZn23bt2iSJEieRqUVRiNkBpparv6EVFzGnUjsj3eoYPVQ4o6mTXlxP+tt6x+fWu6uf8myVHJuHq5UraJepUThRD2YdKkbSxZclS5P2JEffbsGUaVKrZbLVUIIYTl5SqZ6ty5M+PGjWPXrl1cvnyZnTt38vrrr9O5c2dLxWc5SdeVZrTBNEJVI1KtYEyubd2qtB3d3FSMxPIyS6JX7lgZrWyEKYSwsGnTWuLn54mHhxPLlvVi4cJuuLnJdgxCCCGeTq7WTI0fP57o6GjGjBlDWloaLi4u9OnTh3HjxlkqPsvJlkydv22qnqdzyOjIVprcms7+/DMAbgV1E+RckPVSQghrKlnSg9Wr+1OkiAs1atj+71ghhBDWkatkysXFhY8//piZM2cSFxeHt7d3wV3Xk56xQMqjHGS+Br0jkA5eXlYP5+SCBUrbt0kTq1/fmuKuxxFxPAI0ppEpIYTISxcuRPPGG1tZvLgH3t7uSn/jxmVUjEoIIYQteuz5VfPmzWP06NEsX74cZ2dnSpQoUXATKYDLP5luUyOJSrkLgJNBnVCMRiPHv/lGud949mx1ArGS85tMo1JlGpfBPdsHHSGEeFqrVp0iIGAR69efY/DgNRgMRrVDEkIIYcMeK5n69NNP+eWXX3BycmLu3LksWrTI0nFZnpuf6Vafwq1E05S/ZjdMFZ7ItmmuNeiTk5V27VGjCnaS+giGdAOnVp4CZIqfECLv6HR6JkzYQt++IcTHm36HX7oUQ0REgsqRCSGEsGWPlUxt2LCBH3/8kblz5zJ37lzWr19v6bisICNhqT6Rnaf/BSDcuZCpLyXFqpEYjVnfnNZ89VWrXtvaQoJCuLz9Mhqthhq9aqgdjhDCBly9GkuzZkuYM2e/0jdgQG0OHRqOn18hFSMTQghh6x5rzdS9e/eoUsU0ihAQEEBERMQjnlGwXDpdCIoAhowKFI0aWfX6cRcuKG2Ng8NDjizYIo5HcGbtGbROWnr93IsSNWURuBDi6WzYcI4hQ9YQE2P6EszZ2YE5czoycmSATY/yCyGEyB8eK5nSarMGsBwdc1WzokC4y2kAGt9S57XtmjhRaTs4O6sSgzUcX34cgKpdq1K7f22VoxFCFGRpaXref387n366R+mrWLEoISFB1K/vp2JkQggh7MljTfPLPg3NZiRcVJrX4q8AYHDTmTqsOPJmNBpJtrGRvvsxGoycDDZtSlxnUB2VoxFCFHQbN543S6R69arO4cMjJJESQghhVY81FJOens7atWuV+2lpaWb3AXr27JmHYVnB9dWm29RoUtxN0+wMDkWAeGjc2GphXNuyRWm3+u47q13X2q7uukr89XhcirhQtUtVtcMRQhRwPXpUY8iQZ/nllxN89lk7xo9vJNP6hBBCWN1jJVPe3t7MnTtXuV+0aFGz+xqNpuAlU4WqwL3zpLtXh6JLAWh2KWMjXxcXq4WRcD1r82A/G95f6vgy0xS/mn1r4uhqe1NFhRCWZTQazZIljUbD/PmdGTeuIYGBpVSMTAghhD17rE+127dvt3QcqtEVeQ5SC6Nxic3qtGJp9GNz5gDg17Sp1a5pbemp6ZwONa1Lkyl+Qojcun07gUGDVjN2bAN6ZasC6uHhLImUEEIIVdnvEIFRn9VO88A3LTbrfu/eVglBFx+vtD1Kl7bKNdVwftN5UmJTKFS6EOVblFc7HCFEAbJjxxVeeGEVt28ncPhwOM8+60vFikXVDksIIYQAHrMAhc1JugkJlwDQ6w1Q+CbeSdke9/a2Shh/jRihtBv8739WuaYaTiw/AUCdgXXQaGVNgxDi0QwGI7Nn/02bNj9x+7Zp4113dyciI5Me8UwhhBDCeuxzZCoyqwLUqn+eAaBBeEaHr69VQtDrdESdOKHc12htM69NiU3h3PpzgEzxE0I8nsjIJF58cTVbt2ZVXW3btiLLl/emZEkPFSMTQgghzNlnMnXpJ9Nt0XpcuxkJQJnMGXe3b1slhOu//660Wy5YYJVrquHUqlPodXpK1CqBT10ftcMRQuRzu3dfo3//UG7evAeARgPTp7fkvfea4eBgm186CSGEKLhy/ZdJp9Px+++/s3TpUpKTkzlz5owl4rKsOztMtwmXuKHLGB0yZvwoXn3VKiEcnDVLaZdq1swq11RD5hS/ui/WlbLFQogHMhqNfP75Hlq0WKokUiVLevD774OZOrWFJFJCCCHypVyNTF27do1hw4aRlpZGfHw8LVq0oE+fPsybN49WrVpZKsa8V6gqxByB8oO5c8u0dqpYisH0mIODxS+ffPcuadmKT9iq+BvxXNlxBYDaL9RWNxghRL52504iH330D3q9aZP4Fi3KERzcBz+/QipHJoQQQjxYrr7qmz17Nr1792bHjh04OjpSoUIFZs2aZbbnVIGQblrMjF977qSZkqnx+zMeS0iw+OX3T5umtDutWmXx66nlRPAJMMIzzZ7Bq5yX2uEIIfIxHx9Pfv65F1qthilTnuePP4ZIIiWEECLfy1UydfToUV599VU0Go0yZatHjx5cz7bxbIFwz1QQAaOBqPRrAJwqXsTUZ4WRqfCdO5V20erVLX49tWSf4ieEENkZjUZSU9PN+jp3rsKZM68xe3YbHB1lWp8QQoj8L1d/rQoVKkRkZKRZ3927dylSpEieBmVxToVNtx5lMRhNf8xrRsWZ+gYMsOilDWlpSrtZQRvRy4U7J+8QcSwCrZOWmn1rqh2OECIfiYtLoV+/UF56aS1Go9HssSpViqsUlRBCCJF7uUqmunXrxtixY9m9ezcGg4Hjx4/z1ltv0aVLF0vFZ1mOhbmQug+HbPv3WnqPqdhz55R2qeeft+i11HR8+XEAqnSuglsxN5WjEULkF0eP3iYw8DtCQ0+xYsW//N//HVI7JCGEEOKJ5aoAxZgxY0hJSWHs2LEkJyczePBg+vbty9ixYy0Vn1X4ZV8mVa+eRa8Vky2ZcnBxsei11GI0GDn5y0lA9pYSQpgYjUa+//4I48ZtJjXV9A1WkSIulC4t66KEEEIUXLlKppycnJg8eTKTJ08mOjqaokWLFsxy1/pUpemAI9UjM+btOzqCk5NFL73//fcBcLfS5sBquPbPNeKuxeFS2IWqXauqHY4QQmUJCTpGj97IsmXHlb6AAD9WrgyiYsWiKkYmhBBCPJ1cJVNr16594GM9e/Z8ylCsxJAGBlMyZTAa0JNOYHjGY+npD35eHtDFxSltDz8/i15LTZlT/Gr0qYGTm2WTUyFE/vbvv3cICgrh9Oms9bavvdaAL75oj4uLfe4bL4QQwnbk6i/Zf0ugx8XFkZycTEBAQMFJplKjlOaVdNOoWoJzRsezz1r00pEnTijtlgsXWvRaaklPTedUyClApvgJYe9++ukYo0dvJCnJVHinUCFnvv++O/361VI5MiGEECJv5CqZ2r59u9l9o9HId999R2xsbF7GZB0aLUbNf8qgV6tm0UuemD8fAK2TE04eHha9lloubL5ASkwKhUoVonzL8mqHI4RQidFoZPXq00oiVbeuDyEhQVStKtX6hBBC2I6n2shDo9HwyiuvsG7duryKx/ISTJv0YjQQdjsMgPJRlp+Kdv3334k6dgwwL49uazL3lqr9Qm20DrJPjBD2SqPRsGRJD8qX9+LVV/3Zt+8VSaSEEELYnKeesH758uWCVYTCoFOaV2KvAPDmgYzk5vZti102c1QKoNWiRRa7jprObz7P2fVnAZniJ4Q9ioxMwtvbXblftKgbhw+PoJhsjyCEEMJG5SqZGjx4sFnilJaWxtmzZ+nevXueB2YxybdMt0VqokED2feLLFXKIpc0Go3K/lLFn30Wv6ZNLXIdNZ1ec5qVvVcCUKpBKXzr2W61QiGEudTUdN54Yyuhoac5enQkfn5Z5c4lkRJCCGHLcpVMNWrUyOy+Vqvl5Zdfpm3btnkalEXtGWi6jTtFSqEUat/J9ti8eRa55MWQEKVduW9fi1xDbWfWnAGgWo9qdPuuW8EarRRCPLFLl2Lo1y+Ew4dNX1S98MIq/vxzCA4yzVcIIYQdyFUyFRMTw8SJE/H09LRUPJbn1wFubQXPyuy6totGN7I9Vjzv5/PrdToOzJih3K9YUKoe5tLNAzcBCBgZgEcJ2yyuIYQwt3btGV5+eS1xcabtJlxcHHjxxbpotfJlihBCCPuQq68O169fj5ubjUzZqDOVc1HnaHTTspe59c8/Srv2qFFotLb3bW1KXApRZ00l50s3KK1yNEIIS0tL0/Pmm1vp1WuFkkhVqVKM/ftf5dVX68vItBBCCLuRq5GpPn36MGPGDHr37k2JEiXM/mCWstB6ozx3a6vS9PH04dnblwG4W7oeJSxwuZTIrI0q644bZ4ErqC/8kGnXY68KXrhnW3wuhLA9167F0b9/KPv2ZQ3rBwXV5Pvvu1O4sIuKkQkhhBDWl6tkasmSJQCsXLlSSaSMRiMajYbTp0/nfXR5zZit2oRBhwYN14tAw3DwDLDMHlMaR9OP2Oc/681sSfhBUzIlo1JC2LYtWy4waNBqoqOTAXBy0vLVVx0YM6aBjEYJIYSwS4+VTB0+fJiAgAD+/PNPS8djWYbUrLZfJ/beeJW6Eaa7qY2aY8kJjA6urhY8u7oyk6lSDQvI6KQQ4onExCQriVT58l6sXNmXBvIlihBCCDv2WMnU8OHDOXLkCKVL29AfTSdPSriXwEN3FwBtUoJFLnPi229NjeyjYjYms/iEjEwJYdteeKEOu3ZdIzz8HkuW9KBoURtZQyuEEEI8ocdKpow2nAjoHEy3aVVqWuT8SRkbAcecOWOR86vt3q17xN+IR6PV4FffT+1whBB56PTpu9SoYb6adM6cjjg6amVanxBCCMFjVvOz5T+a5eNMt0aXvJ+GZzQYlLbNFp/ImOJXomYJnD2dVY5GCJEX9HoD06b9Ra1a81m+/LjZY05ODjb9N0EIIYTIjccamUpOTqZNmzYPPaagr6fSlyln0fOXbtnSoudXy82Dpil+sl5KCNsQEZHAoEGr+fNPU6XTkSM30KRJWSpUKKpyZEIIIUT+81jJlJOTE2PHjrV0LFZXNlqvtA1exSx7MRv9Jjf8gFTyE8JW7Nx5hQEDVnH7tmkNqVar4b33mlGunJe6gQkhhBD51GMlU46OjvTq1cvSsVjdt8uilXbRysXz/Pyb+/RR2g7OtjcFzmg0Zo1MNZCRKSEKKoPByCef/MP77/+FwWBaI+vr68mvv/ahRYvy6gYnhBBC5GP2VYAi+bbS1Bn0VMzKpbBE5fLYc+eUtpOHR95fQGUxF2NIiUnBwcUBnzo+aocjhHgCUVFJDB68hs2bLyh9bdpUYPny3vj4eKoYmRBCCJH/PVYBiu7du1s6DutIi1OacenplEwytT93eTvPL6XX6ZR2259+yvPz5weZo1K+9XxxcHZQORohRG4dO3Ybf/+FSiKl0cC0aS3YuvVFSaSEEEKIx/BYydSMGTMsHYd1ufkRvPc75e4ubes8v0RKVJTSLuHvn+fnzw+U/aUaynopIQoiHx9P0tJMVUdLlHBn69YXmT69JQ4Oj/WnQQghhLB7dvsXc/6er5X2xuSHVyp8EgnXriltjdY2f8yZZdFlvZQQBZOvryfBwX1o2bI8R4+Ool27SmqHJIQQQhQoj7VmyhYVTc2qrmck7yvtJd+9C4DGwTanvxnSDdw6cguQkSkhCorDh8OpUKEoxYq5KX0tW5anRYtysneUEEII8QRsc8jkQXSxSlNz+47Sbtsu738MEQcOAOBcuHCenzs/uPPvHdKT03Ep7ELxKnlfCVEIkXeMRiPffnuAJk0W89JLa5WKfZkkkRJCCCGejH0lUwmXANgXfQv/jMJ+F7TP0LxF3n+QuL13LwDF69bN83PnB9mn+Gm08kFMiPwqPj6VAQNWMXbsZnQ6PRs2nOOnn46pHZYQQghhE+xrml/0YQDCnXypFG3Kpiobrj3sGU8sMdyUbBQuX94i51dbZvEJWS8lRP517NhtgoJCOH8+ax+ICRMaMXBgHRWjEkIIIWyHfSVTLsUA0Di4KiNT8xmd55dJS0hQ2kUq2eaC7syRqdINZL2UEPmN0Whk8eIwxo7dTEpKOgBFiriweHEPeveuoXJ0QgghhO2wr2QqfAsAsa7P4KG9AkAh7hGTx5c5u2yZ0i7ftWsen119aUlpRJyIAKT4hBD5TWKijjFjNplN5atf34+VK/tSqVIxFSMTQgghbI99JVOFKkH0Qc4mRFE845XvozGF7uXtZQzp6UrbwcUlb0+eD9w+ehuj3oinryeFShdSOxwhRIaYmGSef34Jp07dVfpGjw7kyy874OpqX7/uhRBCCGuwrwIUMUcBKFyovNKVigt5vadu5r5Slfv3z9sT5xPZN+uVKmBC5B9eXq48+6wPAJ6ezgQH92H+/C6SSAkhhBAWYl9/YdOTANgcfpIp57K6a9e2zOVsNc2QzXqFyJ80Gg0LF3ZFp9Mze3ZrqlXzVjskIYQQwqapMjIVFRXFmDFjCAwMpFGjRsyePZv0bFPj7ufcuXM8++yz7N+//8kvnFGA4mJSPJe8TF0ajFSo8OSntEfZR6aEEOo5fz6av/66bNZXqJALoaH9JJESQgghrECVZGrChAm4u7uza9cuQkND2bt3L0uXLn3g8cnJybz55pukpKQ83YWNpo0qfd2KUTHW1HWG6uT1sqYT336btyfMR5Kjk4m+YCqzXCpQRqaEUMsff4TTsOH39OmzkqtXY9UORwghhLBLVk+mrl69yoEDB5g0aRJubm6ULVuWMWPGsHz58gc+Z8aMGbRt2/bpLx5rqm4VFnVR6bpBmac/bza6uLg8PV9+E37INMWvWOViuBVzUzkaIexPamo648dv4Z13jnDvno6YmBTee2+72mEJIYQQdsnqa6bOnz+Pl5cXPj4+Sl+lSpUIDw8nPj6ewoULmx2/du1arl69yuzZs5k/f/4TX1efmlWyr7CzO2BaP3WPQuj1+ic+738l3s2qouU/ZUqenjs/uLH/BgB+gX4299qeVubPQ34uwlIuX47hhRdWc+jQLaXvhRdq8e23neR9JyxCfq8Ja5H3mrCWvH6PWT2ZSkxMxM3NfEQj835SUpJZMnXx4kW++uorgoODcXBweKrrXj26huqYZvrF65LMHjtx4uhTnTu7qN9+U9rHjh17yJEF0+k/TwNg9DNy9OhRdYPJp06cOKF2CMIG7dx5m+nTj3HvXhoAzs5a3nqrFr16PcOFC6dUjk7YOvm9JqxF3muioLF6MuXu7k5ycrJZX+Z9Dw8PpS81NZWJEycyZcoUSpV6+rU55cuWgutwIx0cDVn97dsZqVev3lOfP9OKIUOUdl6eN7/YcW4HAA16NqBsvbLqBpPP6PV6Tpw4QZ06dZ46+RciU1qanvfe+4svvzyk9FWs6MXMmXUICnpe3mvCouT3mrAWea8Ja9HpdJw6lXdfQlo9mapSpQqxsbFERkbi7W2qNnXx4kV8fX0pVChrA9gTJ05w5coV3nvvPd577z2lf9SoUfTo0YPp06fn6rpaB9PysPOulagcnbVmKtHRK8/+p73+xx9K269ZM5v7ZRB/M56EWwloHDSUDixtc68vrzg4OMjPRuSZnj1XsmFD1l4OffrUYNGiLly+fEbea8Jq5L0mrEXea8LS8vr9ZfVkqnz58gQEBPDhhx8yc+ZMYmJimD9/Pn379jU7LjAwkOPHj5v1VatWjQULFtCoUaMnvn72ihvJuHLputMTn+u/do0fr7Sbz52bZ+fNLzJLopesXRIn97z7uQkhHmz48Pps2HAOJyctX3zRnrFjG2IwGB79RCGEEEJYnCql0efOnUt6ejpt2rShX79+NGvWjDFjxgDg7+/Pb9nWHeUVTVpsjr5EPPD3z5vzRxw8qLS9qlXDwdk5b06cj8hmvUJYX/fu1fj007b8888wxo1rhEZjq9uBCyGEEAWP1UemALy9vZn7gJGbsLCwBz7v7NmzT37RuIy5kSmRZt15tawpIttmwu0fUua9IJPNeoWwrFu37vHzz8eZNKmJWdI0aVJTFaMSQgghxIOokkypQXv2SwDOGj2BrL2gGjbMm/NfXLUKgFItWuDoZnv7LxkNRmWPqdINJJkSIq9t336ZgQNXERGRSNGirgwfHqB2SEIIIYR4BFWm+anB6P08AAbnYhY5f/KdOwB4lsnbTYDzi6jzUaTGpeLo5kiJWiXUDkcIm6HXG/jgg520a/czERGJAHzyyW50OtlrRQghhMjv7GZkShP5j+m2eEMgb/cwiDlzRmmXbdMmT8+dX2Sul/Lz98PBSarsCJEX7txJ5MUXV/P775eUvvbtK7FsWS+cneX/MyGEECK/s5uRqUyj9/2Axph13ykPitJFHDigtEsEBj79CfOhzPVSUnxCiLyxa9dV/P0XKomUVqvhgw9asXnzIEqU8HjEs4UQQgiRH9jNyBRAekYSVT2jBoUbyXmyZurU998D4FSoEFob3Rshc2RKik8I8XQMBiOff76HKVP+RK83/VLy8fEgOLgPrVpVUDk6IYQQQuSGXSZTThlbtHiQBHlQZdiQng6Ai5fX058sH9Kn6bkVdguQkSkhntbHH//De+9tV+63bFme4OA++Pp6qhiVEEIIIZ6EXU3zy5zdF2gaZOG4Q95sMqV1NOWk1QYPzpPz5Td3TtxBn6rH1cuVYpUtU8BDCHsxcmQAZcsWRqOB999vxh9/DJZESgghhCig7Gpk6vck0210RuVyJ3R5cl5HDw+IisKratU8OV9+c/Ng1nop2TBUiKdTvLg7ISFBxMSk0LFjZbXDEUIIIcRTsKuRqWSj+f3Djo3z5Lxp9+4BWSNUtkY26xXiycTGpjBixHoiIhLM+hs1KiOJlBBCCGEDbPPT/yOU9agIXHrkcY/DkJZGakyM6Y7R+PCDC6jM4hOyXkqIx3fkyC2CgkK4dCmGixdj2LbtRRwc7Or7KyGEEMLm2eVf9jG/ZSZST5/87HnnHaVdtHr1pz5ffqNL1HH337uAjEwJ8TiMRiMLFhziued+4NIl0xctYWG3OHcuSuXIhBBCCJHX7HJkKlP51HNPfY5rW7YobUd396c+X35z68gtjAYjhUoXopBfIbXDESJfu3cvlZEjNxAcfFLpa9iwNCtX9qVcOS/1AhNCCCGERdjlyFSCi2kvqPeZ9VTnSYmOVtqV+/V7qnPlV8p6qQYyKiXEw5w4EUFg4HdmidT48Y3YtWuoJFJCCCGEjbLLkSnPVD0AvvWfbg1Q7LmskS3/t956qnPlV8p6qYayXkqIB1myJIzXXttEcrJpz7nChV1YvLg7ffrUVDkyIYQQQliS3SVTbtmqoccnPd3L3/naawAUKl8eJw+PpzpXfiUjU0I83J491xk27Dflfr16voSEBFFZ9mQTQgghbJ5dTfM7lgqFU7Pu33Ip/8TnMhoM6FNSALh35crTBZZPJUUmEXs5FoBSgTIyJcT9NGlSluHD6wOmDXn37n1FEikhhBDCTtjVyJRztv1m9WgJCHzyDWivbNigtHv8/vvThJVvhR8yTfErXrU4rl6uKkcjRP41Z05HunatSvfu1dQORQghhBBWZFcjU0+eOuV0cuFCpe1RyjZHbWSzXiHMpaSkM2rUBlasOGnW7+bmJImUEEIIYYfsamQqL2VO7fOqWlXdQCxINusVIsuFC9EEBYVw9Ohtli8/gb+/H1WrFlc7LCGEEEKoyK5GpiyhXOfOaodgEUajUUamhMiwatUpAgIWcfTobQDS0w38++8dlaMSQgghhNrsamTqcpr5/YiIJztP+K5dSrtCt25PEVH+FX89nsQ7iWgdtfjW81U7HCFUodPpmTRpG3PnHlD6qlUrTkhIEHXq+KgYmRBCCCHyA7tKpsJSze/XqPFk54k5fVppu/vaZqKROSpVsk5JHF3t6m0iBABXrsTSv38oBzL+XwAYMKA2ixZ1pVAhFxUjE0IIIUR+YVefkq+lwzOJprYGIz5P+MWyg6upsl3JBg3yKLL85+ZBmeIn7Nf69Wd56aW1xMSYtj9wdnZgzpyOjBwZgEaTl6VshBBCCFGQ2VUyFWuAZ5NNbS1GatV6uvO5lSz59EHlU+EHpPiEsE8JCTqGD1+vJFIVKxYlJCSI+vX9VI5MCCGEEPmN3RSgiNKbbr2TTLf/UpNKlZ7sXMfmzjU1DIanDywfMugNhB82JVMyMiXsjaenM8uW9Uajgd69a3DkyAhJpIQQQghxX3YzMhWfkUyViTfdVuAyNx98+AOlJSaiTzYNbyXfvZs3weUzUWej0N3T4eTuRIkaJdQORwiLMxiMaLVZ0/fatq3I3r2v0LBhaZnWJ4QQQogHspuRqQsZlfwyR6aO8ewTnSekYUOl3fTzz582rHwpc72UX4AfWke7eYsIO6TXG/jf/7YTFBSC0Wg0e6xRozKSSAkhhBDioexmZMoh4/aZBC1gQK/0PL6/Ro1S2sXr1sWthG2O2shmvcIe3L6dwMCBq/jrrysAfP31PiZOfE7doIQQQghRoNhNMpWU8aWzwaMYEMl5qtC4Qu7OcSvb/lLtf/kl74LLZ2SzXmHr/vrrMi+8sIqICFN5TwcHDQaD8RHPEkIIIYQwZzfJ1OmMaX4Bl0yLpm5RCsdcvPrYCxeUdpd162x2+k96ajoRx0y7GZduIMmUsC0Gg5GPPtrF1Kk7lOSpVKlC/PprH5o1K6dydEIIIYQoaOwmmSqUsfTHoDU1qnndztXzb+/Zo7SLVK6cZ3HlNxHHI9Dr9LgVd8Orgpfa4QiRZyIjk3jxxdVs3XpR6WvXriLLlvWmZEkPFSMTQgghREFld9UFnr1h2jvmqFuTXD3PMWOjXtfixfM8pvwkc71U6QZSxUzYjt27r1Gv3gIlkdJoYObMlmzePEgSKSGEEEI8MbsZmcqU6qjFJd3AkVu+uXre9e3bAShWu7Ylwso3MtdLSfEJYUu+/fYgN2/eA6BkSQ9++aU3bdpUVDkqIYQQQhR0dpVMaQ3gkm7aaLd2y8evxGdIS1OKT6RERloktvxCGZmS4hPChixY0JWDB8MpXboQwcF98PMrpHZIQgghhLABdpVM1ci2x+61InUe+3knFyxQ2vUmTszLkPKV1Hup3D1t+iHJyJQoyJKS0nB3d1LuFy7swl9/vYSvryeOsneaEEIIIfKIXX2qcMhW+ThB7/bYz8ueTPk+Z7v70Nw6fAuMUOSZInj6eKodjhC5ZjQa+eab/VSuPJfr1+PMHitTprAkUkIIIYTIU3bzyWJ3clY7HD+Skh7veUZjVgZWY+jQPI4qf5H1UqIgi4tLoV+/UF5/fQu3biXQv38oaWl6tcMSQgghhA2zm2l+3g7m9xs3frznnQ8OVtp1xozJw4jyH1kvJQqqo0dvExQUwoUL0Urfc8+VUTEiIYQQQtgDu0mmnrTI96HZs5W2o7t73gSTT8nIlChojEYj339/hHHjNpOaahqFKlLEhaVLe9KzZ3WVoxNCCCGErbObZGpdIhTJ5XOMBoPS9mvWLG8DymcS7yQSdy0ONFAqQJIpkf8lJOgYPXojy5YdV/oCA0uxcmVfKlQoqmJkQgghhLAXdpNMRepzn0xd27ZNaTecOjVvA8pnbh40jUp5V/fGpbCLytEI8XD//nuHoKAQTp/O2qpg7NgGfP55e1xc7ObXmhBCCCFUZjefOnwcQGN89HHZGdPTlbZHKdsercmc4le6gayXEvnfuXNRSiJVqJAz33/fnX79aqkclRBCCCHsjd0kUwA1Mr7EdiItV8+z5XLomTKLT5RqaNtJo7ANvXrVYMKERmzffoWQkCCqVi2udkhCCCGEsEN2lUw1uW66LUEkUVGPPj78n38sG1A+YTQaZWRK5Gu3bt3D19cTjSarlMwnn7RDrzfg5ub0kGcKIYQQQliO3ewzFaGHyIxifGepSkDAo59zZf16ACKPHrVcYPnA7bDbJEclo3XS4vOsj9rhCGEmOPgEVavOY8mSo2b9zs4OkkgJIYQQQlV2k0wBtLtouv2TNlSq9PjPq/rii5YJKJ/Y89keAGr2qYmjLN4X+URKSjqjR29g4MDVJCToeO21TZw8eUftsIQQQgghFHb1ydk3IeOW23h6PvzY7GXRK3TtasGo1BVzKYZ/V/4LQNPJTVWORgiTixejCQoKISzsttIXFFSTChW81AtKCCGEEOI/7CqZylxtcYT61Cz88GMTw8OVtkeZMpYLSmV7Pt+D0WCkcsfK+NbzVTscIVi9+jRDh64jPj4VAFdXR+bN68SwYf5ma6aEEEIIIdRmV8mUzsF0e5y6PLLSuTGrjrqjq6vlglJR4p1EjmasQ5FRKaE2nU7P5Mm/8/XX+5W+KlWKERraj7p1ZS2fEEIIIfIfu0mmHPRZpdF1OOP4iFeeGhsLgKObm2UDU9HJFSdJT0mnVGApyrUop3Y4wo7duBFP374r2b//ptLXv38tFi3qRmHZRFoIIYQQ+ZTdJFN+CVntgzTA3f3hx9/Yvh2A9ORkC0alrrPrzgJQa0AtmT4lVOXq6siNG/GAqUrfV191YPToQHlfCiGEECJfs6tqfgApuFC8yqM3+Iw5e9YK0agnOSaZKzuuAFC9R3V1gxF2z9vbnZUrTZvv7tkzjDFjGkgiJYQQQoh8z25GpjIZ0VCz5qOPizp+HIBynTpZOCJ1nN90HqPeSIlaJShWuZja4Qg7c/NmPM7ODpQo4aH0NWlSln//HYOjo919xyOEEEKIAsouP7U8svgEUCRjI6pC5WxzLdHZtaaRt2o9qqkcibA3v/9+EX//hbz44hr0eoPZY5JICSGEEKIgkU8uD3Dn0CEAvKpWVTmSvKfX6bmw9QIgU/yE9ej1BqZN+4sOHZZx924S27Zd5Ouv96kdlhBCCCHEE7O7aX6P4+6RI0rbxctLvUAs5OrfV9Hd0+Hh40GpwMcYphPiKUVEJDBo0Gr+/POy0tepU2VeeqmeekEJIYQQQjwlSabu49QPPyjtkg0aqBiJZZzbeA6AKl2qoNHKIn9hWTt3XmHAgFXcvm0qqanVapg1qxWTJz+PVt5/QgghhCjAJJm6j8w9ppwKF0ajta2ZkEajkXPrTclU1S62N4VR5B8Gg5FPPvmH99//C4PBtAm2n58nwcF9aNGivLrBCSGEEELkAUmm7iPy6FEAqg8Zom4gFhB1LoqYizFonbRUbFdR7XCEjUpNTadXrxVs3nxB6WvTpgLLl/fGx8dTxciEEEIIIfKObQ27PESTa7l/TqGyZfM+EJWd33gegPIty+NSyEXlaIStcnFxxNfXlDRpNDBtWgu2bn1REikhhBBC2BS7GZn6boPp1o0UDIaHH5vJt0kTywWkkku/XwJM66WEsKR58zpz7Vockyc3pV27SmqHI4QQQgiR5+xmZGrnM6bbXTTh9u0HH6fX6awTkEqizkcB4FvPV+VIhC2JiUnmn3/Mh3/d3Z34448hkkgJIYQQwmbZTTKVaZ52FK+88uDHE27cUNrORYpYISLrMegNxF2LA6BohaIqRyNsxaFD4QQELKJLl1+4cCFa7XCEEEIIIazG7pIpgE6dHn2MU+HCaB0cLB+MFd27eQ9DmgGtk5ZCpQupHY4o4IxGI99+e4CmTRdz+XIs8fGpjBq1Qe2whBBCCCGsxm7WTBVJMd06OYHjQ1513AVT9TFb3P0m5nIMAF7lvNA62GUeLfJIfHwqw4evZ+XKf5W+xo3LsHhxDxWjEkIIIYSwLrtJpurdMd1q0tMfelz0v6YPh7r4eEuHZHUxlzKSqQpe6gYiCrRjx24TFBTC+fNZU/omTmzMxx+3xdnZtkZzhRBCCCEexm6SqVseUCYRbhhLPfS4U99/D0CxWrWsEZZVxV6OBSSZEk/GaDSyeHEYY8duJiXF9KVEkSIuLFnSg169aqgcnRBCCCGE9dlNMpXJu0rxxzpOo7W9aXCZyZQUnxBP4o03tvL11/uV+/Xr+7FyZV8qVSqmYlRCCCGEEOqxvYzhES5fdHrgY6mxsUq76WefWSEa68pcM1W0oiRTIvc6dKiMJmMx4ZgxgezePUwSKSGEEELYNbsZmfJLNN22afPgY7KXRfcsW9bCEVmfrJkST6Njx8rMmtWaihWLMmBAbbXDEUIIIYRQnd2NTCU7FX7gY+G7dlkxEutKS04j4VYCINP8xKMlJ6exaNFhjEajWf+UKc0kkRJCCCGEyGA3I1OZ7npWeOBj8ZcuWTES64q7atqs19nTGbfibipHI/Kz8+ejCAoK4dixCFJT0xk3rpHaIQkhhBBC5Et2NTK1rGyVhz4eefw4AKWaN7dGOFaVfb2URmOLu2iJvBAS8i8BAYs4diwCgKlTdxAbm6JyVEIIIYQQ+ZNdJVNxTs4PfbxwBdOoleczz1gjHKuSsujiYUwjUJvo1y+Ue/d0AFSv7s2uXUPx8nJVOTohhBBCiPzJ7qb5PUxKZCQAxWrY3p45UnxCPMjlyzH06xfKoUPhSt/AgXVYuLArnp4P/wJCCCGEEMKeSTKVTczp0wAY0tJUjiTvyR5T4n7WrTvDyy+vU6byubg4MHduJ4YPry/TQYUQQgghHsHukqnLlx99jLuvr+UDsbLMNVMyMiUyLVt2nMGD1yj3K1cuxsqVffH391MxKiGEEEKIgsOu1kwBtGp1/369Tqe0M9dO2RJlZEo27BUZunatSsWM90PfvjU5dGi4JFJCCCGEELlgdyNTro+xlt65SBHLB2JFyTHJpGRM4/Iq76VuMCLf8PJyJSQkiN27rzF2bEOZ1ieEEEIIkUt2NzJljzJHpTxKeuDsIQUF7FF6uoEPPtjJzZvxZv316/sxblwjSaSEEEIIIZ6AXSVTRocH75eTGJ5VyUzr5GSNcKxG1kvZt/Dwe7Rp8xNTp+5gwIBVpKXp1Q5JCCGEEMIm2FUyVSja+4GP6VNTlbbj48wFLECkkp/9+vPPS/j7L+Tvv68CsHfvdfbsua5yVEIIIYQQtsGukqkrzsUfeYyr94MTroJK2WOqope6gQir0esNzJy5k3btfubOnUQASpcuxM6dL9OiRXl1gxNCCCGEsBF2VYDitlNhHlj03Gi0ZihWJSNT9uXOnURefHE1v/9+Senr2LEyP//cC29vdxUjE0IIIYSwLXaVTBl58CL7/VOnApCenGytcKxG1kzZj127rjJgwCrCw+8BoNVq+OCDVrzzzvNotVJkQgghhBAiL9lVMnXG1ZcH7aIT/e+/AKQnJlovICswGozEXokFZGTK1p0/H0WrVj+i15tGWX19PQkO7kPLluXVDUwIIYQQwkbZ1ZqphylasyYA/pMmqRxJ3rp36x76VD0aBw2FyxZWOxxhQVWqFGf06EAAWrUqT1jYSEmkhBBCCCEsyK5Gph4m5tQpAIpUqqRyJHkrc71UkbJFcHByUDcYYXGff96eGjVKMHJkAA4O8l2JEEIIIYQlyaet/5A9pkRBYDQa+frrfSxbdtys38XFkTFjGkgiJYQQQghhBTIyBcRdyqp6ZqsjU5JM2Y7Y2BSGDVvHmjVncHd3wt/fl1q1SqodlhBCCCGE3bGrr6813L/8+ZFPPlHabiVKWCscq8jcY0qKT9iGI0duERCwiDVrzgCQlJRmVgJdCCGEEEJYj12NTEU4FSYmJme/LZZDzyQjU7bBaDSycOFhxo/fgk6nB6BoUVd++qkXXbtWVTk6IYQQQgj7ZFfJVLSjO7Vq5ezXOpp+DI0//NDKEVle3LU4ALzKe6kbiHhi9+6lMmLEBn799aTS17BhaVau7Eu5cl7qBSaEEEIIYefsKpkCKPyQ6uCZSZWtMOgNxN+MB0zV/ETBc+JEBH37hnDuXJTSN358Iz79tB3OzlKdUQghhBBCTbaVPTyhuAsX1A7BIhIjEjGkGdBoNRQqVUjtcEQupacb6NVrBRcvmuamFi7swuLF3enTp6bKkQkhhBBCCLCzAhSxDu737U+JMn3rb9DprBmOxcVdN03xK1SqEFpHu/pPbRMcHbUsXtwDrVaDv78vR46MkERKCCGEECIfsauRqVStE3q9eV96SorSLlanjpUjsqz466YpfoXLPmRuo8jXmjcvx6ZNA2nRojyurnb1v6sQQgghRL5nN8MVh/wAxxS8vc37k27fVtqeZcpYNygLyyw+UeQZWS9VECxffpz+/UMxGMxL+HfoUFkSKSGEEEKIfMhuPqE5pwO36+HjY95/eskSpa11crJuUBaWOc1PRqbyt5SUdMaP38yiRUcAqFfPh3ffbaZyVEIIIYQQ4lHsJpkqkgq45Oy/d/UqAO6+vmgdbKs6Wvy1jEp+MjKVb124EE1QUAhHj2aNkF68GIPRaESj0agYmRBCWJ7RaCQ9PR39f+fgC7uT+R5ISUnBwcY+jwnrcnBwwNHR0Wqfo+wmmdr9DBCRs9+5kKnKXbHata0bkBVkjkxJWfT8KTT0FMOGrePePVPhEzc3R779tjNDh/qrHJkQQlieTqfj1q1bJCUlqR2KyAeMRiOOjo5cvXpVvkwUT83d3R0/Pz+cnZ0tfi27SaYe5N716wD4NGyociR5TwpQ5E86nZ5Jk7Yxd+4Bpa9ateKEhARRp47PQ54phBC2wWAwcPnyZRwcHChVqhTOzs7yAdrOGY1GkpOTcXNzk/eCeGJGoxGdTsfdu3e5fPkyVapUQau1bIkI+0qmDDlfbsrduwDoU1OtHY1Fpaemk3A7AZBpfvnJlSux9O8fyoEDN5W+F16ozcKFXSlU6D7zUIUQwgbpdDoMBgNly5bF3f3+25YI+2I0GjEYDLi6ukoyJZ6Km5sbTk5OXL16FZ1Oh6urq0WvZzfV/ACIrpSjy7V4cQAKlStn7Wgs6t7NewA4ujri7i1/qPKLTz/drSRSzs4OLFjQheXLe0siJYSwS5b+xlgIYZ+s+bvFvkamyPlNR9zFiwA4eXhYOxiLyiyLXrhMYfmGJx/57LN27NhxhdRUPSEhQdSv76d2SEIIIYQQ4gnZWTJlLiU6Wmm7/7dmegGnFJ+QKX6q0usNODhkfTvi4eHM+vUv4O3tTpEilh12FkIIIVJTU4mJicHX11ftUISwSXY9vp6WkKC0C1eooGIkeU+KT6hv69YL1KjxLZcvx5j1V6pUTBIpIYQooFq3bk2dOnXw9/fH39+fevXq8fzzz/PJJ59gMBjUDi+HgQMHsmfPHqte89ixY4wYMcKsLz09nebNm9OkSRNS/7NO/caNG1SvXp3w8PAc53rnnXd45513zPr++ecfhg8fTuPGjQkICKBHjx78+uuvef4agoKC8Pf3p3Xr1oSEhDzwWJ1Ox2effUbz5s1p0KABr732Grdu3brvsZMmTWLw4MHK/QULFijvpcx/NWvWpEOHDsoxP/74I61bt6Z+/fp069aNrVu3mj1/SbY9U4X1qZJMRUVFMWbMGAIDA2nUqBGzZ88mPT39vscGBwfToUMH/P396dChA8uXL3+qaxfJNlCTdi9jXZGNTfGDrGl+MjJlfXq9gf/9bzudOi3n/Plo+vULJTX1/u9vIYQQBc+MGTMICwsjLCyMo0eP8sMPP7B27VrmzZundmg5xMTEPPqgPKTT6Zg8eTKTJ08269+2bRs+Pj74+vqybt26Jz7/0qVLmThxIt27d2fHjh0cPHiQ9957j2+//ZZPP/30acMHIC4ujhEjRtCzZ08OHjzI7Nmz+eijjzh+/Ph9j//iiy/Ytm0bP/zwA7t376ZcuXIMHToUnU5ndlxoaCgbNmww6xs1apTyXgoLCyM4OBhPT09mzJgBwM6dO1m4cCHff/89R44cYezYsUyYMIEbN24AMGzYMFauXMnFjGUrwvpUSaYmTJiAu7s7u3btIjQ0lL1797J06dIcx/3xxx98+eWXfPLJJxw5coSPP/6Yr7/+2iwjz63so9wn/u//AEhPTHzi8+VXMjKljsjIFDp0WM6sWbswGk19Pj4epKRIMiWEEI9iNEJiovX+Zf6eflrVqlWjQYMGnDp1CjAlFHPmzKFNmzY0bNiQ4cOHc/XqVbPjZ82aRaNGjRg1ahQA69evp2vXrvj7+9OpUyc2bdqkHL9x40a6detGQEAAvXv35p9//lEeGzx4MB9//DG9e/emXr169O7dm0OHDgGmD9rh4eFMmzaNmTNnsn//flq0aMGbb75JYGAgixYtwmAwsGjRItq2bUtAQAB9+/Zl165dyvlbt27NwoUL6dmzJ/7+/vTs2ZN9+/Y98GcREhJCmTJlqFTJvOjXsmXL6Ny5MwMGDGDJkiUYn+CHHxERwWeffcaMGTPo1q0brq6uaLVaGjZsyEcffURUVBRpaWk5nne/0Z/Mf/cbDdu2bRteXl4MGjQIR0dHnnvuObp16/bAL/Q3bNjAa6+9RpUqVXB2dubNN98kIiKCvXv3KsdcuHCB+fPnExQU9MDXp9PpmDBhAkOHDqVx48YAXLp0CaPRqPxzcHDAyckJR0fTSh1nZ2d69erF3Llzc/WzFHnH6snU1atXOXDgAJMmTcLNzY2yZcsyZsyY+75BIyIiGD58OPXq1UOj0eDv70+jRo04ePDgk13caP5yHW24HKsyMiUb9lrNX39dYdCgXezYYfqD6eCg4ZNP2vLbby/ItD4hhHgEoxGefx48Pa33r1mzp0+o0tLS2L9/P/v27aNp06YAfPXVV+zYsYOlS5eya9cunn32WYYNG2Y2ve3atWvs2LGDTz/9lP379zNlyhQmTZrE4cOHeffdd3n77be5cOECO3fuZNq0aUydOpUDBw4wbtw4xo0bx/nz55VzrVixgrfffpsDBw7Qrl07Ro8eTUxMDIsXL6ZUqVLMmDGDqVOnAnD79m0qVqzI3r17GThwIN9++y3Lly9nzpw57N+/n2HDhjFmzBizUZhVq1YxZ84c9uzZQ/Xq1Zk+ffoDfx6//PILXbt2Nes7c+YMp06donfv3nTr1o3o6Gh27NiR65/133//jYODA+3atcvxWOZUSycnpxyP/Xf0J/u/UqVK5Tj+/PnzVK1a1ayvcuXKnDlz5r5x6fV63NzclPuZhb8uX74MQEpKChMnTmTatGmUKFHiga/vu+++w8nJyWyKZJcuXfD29qZz587UqlWL8ePH8/HHH5utgevatSvbtm0jKirqgecWlmP1AhTnz5/Hy8sLn2wFHypVqkR4eDjx8fEULpw1kjJo0CCz50ZFRXHw4EHefffdJ7t4Ygn0ej16veluWsaIVMD776PP7LQRmQUoPEt72txry28MBiMff7yb6dN3YjCY/iqXKlWIX37pxfPPP4PRaED+E4i8lPn/tPy/LSzNUu81vV5v9m07mJIa02dQa1agNeY6mTIajcyYMYMPP/xQ6fP19WXo0KEMGjQIg8HAr7/+ypw5cyhTpgwAY8aMYeXKlfz111/KWpiuXbvi6uqKq6sra9asoV27djRv3hyAZs2a8csvv1CyZEk++eQTBgwYQGBgIAAtW7akVatWBAcH87///Q+j0UifPn1o1KgRACNHjiQ4OJjt27fTu3dvs59z5s+6T58+ODo64ujoyKpVqxgxYgQ1a9YEoFOnTmzdupXQ0FDq1KmjnP+ZZ55R4l67du19R5YiIyO5cOEC/v7+Zo///PPP9OjRQ/mMFxQUxOLFi2nZsqXyM83+8/3vzzvzNjo6miJFiuDo6PhEI1uPKzExETc3N7NruLq6kpSUdN/rtm/fngULFlC9enV8fHyYP38+qampJCcnYzQamTlzJk2aNKF58+YcO3bM7L9FpoSEBH788Uc++ugjtFqt8rhOp6N69erMnj2batWqsX79et577z0qVqxItWrVAPDz86NEiRLs27ePzp07W+znUpBk/oxNn/vNf3/l9e8zqydTmW/Q7DLvJyUlmSVT2d29e5eRI0dSu3btHN94PA6twQHQcOzYMVxcTG/QmIzFgbdiY0k4ejTX58yv0hLSSI0zfft1NeYqN4/efMQzxJOKjdXxv/+FsXfvXaWvUSNvPvjAH0/PaI4ejX7Is4V4OidOnFA7BGEnLPFec3R0JDk52axow5YtkJSU55d6IHd3SE7O3XOMRiPvvPMO3bt3z/FYcnIy0dHRJCUlMWHCBLOtSdLT07ly5QpJGS+wcOHCSvv27dtUr15duQ8o0+SuX7/OgQMHCA4OVh7T6/U0bNiQpKQkDAYDfn5+Zs8tUaIE4eHhyod/nU5HUlKSMjLm6empHB8ZGUmJEiXMnu/j48O5c+eU52ePNTMRTrrPf6jMkZhChQopj8fFxbFhwwa0Wi1btmxRfhYJCQkcOnSImjVrKu+B9PR0kv/zHyQ1NRV3d3eSkpIoUqQIsbGxxMXF5RiBMhgMxMXFUbRo0RxxLVmy5IFFGlasWIGfn/k2JU5OTsTExJi9xvj4eNzc3O77ul9//XXmzJnDoEGDcHBwoFevXlSuXBk3NzdCQ0M5deoUS5cuJSkpibS0NAwGQ47z/PbbbxQqVIhGjRqZPTZ9+nTq1atHpUqVSE9Pp1OnTvz222+EhITwxhtvKMeVKFGCa9eu3Tc+e5SamkpaWtoDRxPzktWTKXd39xz/o2Te93hAIYijR48yfvx4AgMD+eijj5R5orlh0Jqy0GeffZbMjZBv6/UkA1Xq1sW3Xr1cnzO/uvuv6YO9q5crgU0DVY7Gtm3ZclFJpDQaGDmyKl9+2Qtn55zTDITIK3q9nhMnTlCnTh0cHBzUDkfYMEu911JSUrh69Spubm64uppPg87vNaE0Gg3Ozs64P2CpgKurKy4uLvzwww/Uy/bZ4tKlS/j4+CjPc3V1VdplypTh7t27ZudcvHgx9erVw8/Pj169eplN/QoPD1eer9VqiYmJUZ5rMBiIiIigXLlyuLu7m8Xr4mLaID77563SpUtz584ds2vfunULX1/fHM8HlHPc7/Vnfjnu6uqqtIODg3nmmWdYtGiR2bFTpkwhODiYL774glKlSuHq6sqtW7eoVq2aWRIaHh5O69atcXd3p02bNsyaNYu9e/fSsWNHs/Nt376dcePG8ccff+RIjl577TVee+21HPE+SI0aNdi/f7/Za7x27RrVqlW77+uOiIhg3LhxzJw5EzAlkIsXL6Z+/fp8/fXXXL16lbZt2wKmD/l6vZ4WLVqwbt06ZZrhjh076N69e47Pwnfu3MFoNJpd18XFBTc3N7M+o9Fo9p6yd1qtFicnJypXrpzjd4xOp1PWN+YFqydTVapUITY2lsjISLy9vQG4ePEivr6+FCpUKMfxoaGhzJo1i9dff51hw4Y98XWddZ4AODg4kPn3ILM0umuRIjb1gSQh3PS6CpctbFOvKz/q0qUqkyc3ZcmSo/z8c0+KF4/D2dlJfu7CKky/z+S9Jiwvr99rDg4OaDQa5V9B8qi4HRwc6Nu3L19++SWfffYZJUuWZN26dbz33nuEhoYq0+myn6NXr14MHTqU3bt306RJE3bv3s28efNYuXIl/fv3Z9asWTz33HPUrVuXEydOMHz4cMaMGcOQIUPQaDSEhobSsWNHqlatysKFCzEajbRq1QqNRoOLiwsJCQlm18see1BQEN999x3+/v5Ur16dbdu28ddff7F48WKz1/rf597v9ZcuXRowJQDly5fHYDDwyy+/MGTIkBwJzgsvvMDEiRN56623KFWqFJ07d+abb76hXLlyVKpUiYSEBEJDQzl37hxffPEFGo2GEiVK8PrrrzN9+nT0ej3t2rVDq9Wye/du3n//fV566aX7roHKrfbt2/P555/z448/MmjQIA4fPsz69euZP3/+fV/3jz/+yI0bN5g7dy7p6enMnDmTWrVqUbduXRYvXmx27DfffMOBAwf4+eeflT6j0UhYWBhDhw7Ncf7WrVuzfPlyWrduTY0aNdi2bRv79+/njTfeMDv2zp07lCpVqsD9/2Qpme/Z+/3uyuu/m1ZPpsqXL09AQAAffvghM2fOJCYmhvnz59O3b98cx27dupXp06fzf//3fzRr1uyprpvuaBr2zP4e08WZ1hU5P2BqYUElxScs5969VDw9nc1+Wc2a1ZqJExvj7e3GURuaLiqEEOLJTJ48mW+++YaBAwcSGxtL2bJlmTt3rpJI/VdAQACffPIJn3zyCTdv3qR06dJ8+eWXVKlShSpVqpCUlMSUKVMIDw/Hy8uLl19+2WyvooYNGzJz5kwuXLhAzZo1Wbx4sfIFdd++ffnqq684ceLEfSvJDR06FIPBwMSJE7l79y7lypXjyy+/pGHDhrl+3cWKFaNmzZocPnyY8uXL89dff3Hnzp37Tols3bo1RYsW5ccff+Tdd99l6tSpfP3114wcOZKoqCicnJyoU6cOP/30E2XLllWeN2LECEqVKsXy5cv54IMPSEtLo1y5ckyYMIH+/fvnOub7KVq0KIsXL2b27NnMnTuXYsWK8f777ysV9g4dOsTw4cPZuHEjpUqVYtKkSUybNo3WrVsDpmIY8+fPf+zrxcTEcO/ePbN6ApnGjh2Lg4MD48aNIy4ujnLlyvHtt99So0YN5Zjr168TGxvLc88995SvXDwJjdGSK/geIDIyUinRqdVq6dmzJ2+99RYODg74+/szY8YMunfvTrdu3bhw4UKO4blu3bopQ6mPotfrOXr0KA69O+F/7Y6y0NSQlsavGcPvfXbvxsXLKw9fobq2/287u2btImBUAF3/L/fry8T97d9/g/79Q5k8uSmjRzfI8Xjme61evXoyWiAsSt5rwlos9V5LSUnh8uXLVKhQIcffeJE7gwcPpmHDhowbN07tUABTCfQdO3bw/fff5+p5meuwMqcWise3cOFCzpw5w1dffaV2KPnGw37H6HQ6Tpw4kWe/16w+MgXg7e39wHr4YWFhSnv9+vV5ds21lfwol31UKmPDXgCn+0wvLMgy95iSkam8YTQa+eabA7z11jbS0gxMmLCVBg1KExj49FMJhBBCCFvSr18/fvzxRy5cuEDlypXVDsfm6XQ6QkNDc6xJE9ajyqa9arjjZl4QQBdvSjicPD3R2tg3u8o0v2ckmXpacXEpBAWFMH78FtLSTNWGAgNL4eOTz1dICyGEECpwdnZWpiwKy/v+++/p378/FSpUUDsUu6XKyJRaUlKy2pnJlK2tl4KskanCZW3vtVlTWNgtgoJCuHgxRul7663n+PDDNjg52VYCLoQQomDKXsggv6hfvz7fffed2mHYhTFjxqgdgt2zq2Qq+8bQtppMGY1GZcNemeb3ZIxGI4sWHWb8+C2kpppK6nt5ubJ0aQ969KiucnRCCCGEECK/sKtkqk2brLYyzc/G1ksl3U1Cn6oHDRQqbVuvzRoSEnSMHLmBX37J2qCyQYNSrFjRlwoVcm4EKIQQQggh7JfdrJn6r7TMkakitjV6kzkq5enjiaOLXeXKeSItTc+ePdeV++PGNWTXrqGSSAkhhBBCiBzsJplKc04yu2+r0/yk+MTTKVrUjZUr++Lt7c7KlX2ZO7cTLpKUCiGEEEKI+7CbT4luScUhe2n0zGTKxqb5SfGJ3ElKSiMxUUeJElnV+Ro0KM2VK+Px8HBWMTIhhBBCCJHf2c3IlFO6G9m3J7b1kSlJph7t7NlIGjX6nqCgENLTDWaPSSIlhBBCCCEexW6SKYBLl7LatppMKRv2yjS/hwoOPkFg4HecPHmHnTuv8sEHO9UOSQghhHgser2e69evP/pAIYTF2VUy1aVLVlt37x4ATjaWTElZ9IdLSUln9OgNDBy4moQEHQA1a5agf//aKkcmhBCiIKhWrRr79++3yLn9/f05dOjQI4+bOHEia9euBSA8PBx/f3/Cw8Nzfb1q1apRt25d/P398ff3p169ejRo0IDhw4cXuGRtwYIFvPrqqxY7f3x8PH369CE+48v4TK+//jrVq1fn1KlTOZ7TunVrVq9enaN/9erVtG7d2qzv8uXLTJ48mebNm+Pv70/btm35/PPPSUxMzLPXEBUVxZgxYwgMDKRRo0bMnj2b9PT0Bx6/evVqOnbsiL+/P/379+fgwYNmj//yyy+0a9cOf39/unXrxl9//ZXjHMnJyfTv3z/Hz2HPnj307t2b+vXr06pVK+bNm4cxYwrZ4cOHC9T+WXaVTNnTND8Zmcrp4sVomjT5gQULDit9Q4Y8y4EDr1KzZgkVIxNCCCEgLCyMwMDARx4XE5O1mXypUqUICwujVKlST3TN7777jrCwMMLCwjh69Chr1qwhLi6OyZMnP9H51DJq1Ci+//57i53/gw8+oF+/fhTO9rkxIiKCv//+m969e/PDDz888bmPHDlCr169KF26NGvXriUsLIzvvvuOY8eOMWzYMPR6fV68BCZMmIC7uzu7du0iNDSUvXv3snTp0vse++effzJt2jQmT57MoUOHeOWVVxg+fDiXMqZ5rVmzhm+//ZYvvviCI0eOMHLkSMaNG0dERIRyjvPnzzNo0CCOHj1qdu6YmBjGjBnDmDFjOHLkCN9//z3Lly9n3bp1AAQEBODu7k5oaGievG5Ls6tkKi4uq22LyZQ+TU/CrQRA1kz91+rVp6lffxFhYbcBcHV15IcfurN0aQ9ZHyWEEPmF0Qjpidb7l/1b1jwSEhJCly5dqF+/Pt26deO3335THktJSWHatGk0bNiQFi1a8PXXX9O6dWtlpCv7qNfWrVvp0qULAQEBdOrUifnz5wPw3nvvcejQIRYuXMioUaO4ceMG1apV48aNGwBcv36dUaNGERAQwHPPPcf06dPR6XSPHX+ZMmXo3r07p0+fVvquXbvGqFGjaNSoEa1ateKrr74yO+fGjRvp0KEDgYGBvPLKK/zvf//jnXfeAeCdd97h9ddfp1OnTjRu3Jhr164RGRnJW2+9RdOmTXn++eeZOnUqCQmmzy/p6elMnz6dpk2b0qhRIwYOHMjhw6YvQRMSEpg4cSKNGjWiadOmvPLKK1y8eBGAb775hsGDBysx/fHHH8rIR4cOHVi6dCkGg0GJaerUqYwaNQp/f3/atGnDTz/99MCfyblz59i5cye9evUy6w8ODqZx48a8+uqrbN26lVu3bj32zzm7qVOn0rNnT15//XWKFSsGQIUKFfjqq68oXrz4fUcJDx06pIwo/vdf9vdcpqtXr3LgwAEmTZqEm5sbZcuWZcyYMSxfvvy+MW3YsIGuXbvSqlUrHBwcaN++PYGBgaxatQqAxYsXM378eOrWrYtGo6Fr166sWLECT09PAPbu3ctLL71Er169ciT64eHhJCcnYzAYlNEojUaDm5ubcszgwYP55ptvcvXeVYvdVPMDePbZrHaaDVbzuxd+D6PBiNZJi6ePp9rh5AsGg5E339zK119nTcmoUqUYoaH9qFvXR8XIhBBCmDEa4ffnIXKP9a5Zoim03QUazaOPfQyrV6/m448/Zt68eTRs2JADBw4wduxY3NzcaNeuHR9++CEnT55k3bp1FC5cmBkzZnDz5s0c50lJSWHSpEl89913NGrUiFOnTjFo0CCef/55Zs+ezbVr12jYsCHjxo1TkigwJSKvvPIKjRo14u+//yYlJYVXXnmFb775hjfffPOxXsOlS5dYtWoVzZs3ByApKYmXX36ZLl26MGfOHKKjo3n99dcxGAy8+eabhIWFMXnyZObOnUvz5s3566+/mDBhAt26dVPOuWvXLlasWIGvry+enp4MGDCA8uXLs3XrVtLS0nj33XeZOnUqs2bNYt26dYSFhbF582Y8PDyYO3cuM2bM4LfffmPx4sUkJCSwc+dOtFotU6dO5fPPP+f//u//zF7Dvn37mDBhAp9++int27fn7NmzyrSxl19+WflvtXDhQubNm0doaCgzZ86kQ4cO+Pjk/GwQHBxM27ZtcXbO+vJVp9OxcuVKPvnkEypWrEijRo346aefcj2id+3aNc6fP8/06dNzPObt7a0k0f8VGBhIWFjYY1/n/PnzeHl5mb2+SpUqER4eTnx8vNmIG5jW5bm7u5v1abVaLl26RHJyMufPn0er1TJo0CAuXLhAhQoVeOutt/DwMFVHrl69On/99RcuLi4sWbLE7Dw1a9akY8eOjBs3DgcHB/R6PYMHD6ZDhw7KMc8++yxOTk5s376djh07PvbrVINdjUz5+5tujQaDsmbKlkamlLLoZQqj0ebNH4aCTqvVkJKSNR+4f/9aHDo0QhIpIYTIj/IosqtXYAAAZFRJREFUqVHLqlWr6N+/P8899xwODg4899xz9O/fn19//ZW0tDR+++03Jk6ciJ+fHx4eHkydOhUHB4f7nsvV1VWZilWpUiUOHz5M3bp1H3r9I0eOcPPmTaZMmYKHhwfFixdn3rx5BAUFPfA5o0aNIjAwkGeffZaaNWvy+uuv07p1az7++GMAduzYgU6n44033sDFxQU/Pz/Gjx+vjGisWrWK9u3b07p1axwdHWnXrh1t27Y1u0a9evWoWrUqhQsX5uTJk/z7779MmzYNT09PihYtyuTJk9m0aROxsbG4urpy48YNQkNDuXz5MuPHj1dGWlxdXTlz5gxr164lIiKCDz/8MEciBaZEqU2bNnTu3BlHR0dq1arFiBEj+PXXX5VjMke3HB0d6dOnD3q9nmvXrt33Z7Rv3z78Mz9EZti8eTNeXl48//zzALz00kusXLlSGWF7XNHR0YApcbKkxMREs5EfQLmflJSU4/gOHTqwdu1aDhw4QHp6On/88Qd79+4lNTWV+Ph4jEYjixcvZvr06ezatYuuXbsyfPhwJbkvWrQoLi4u941Fp9Ph5eXFnDlzOHbsGMHBwWzcuJGQkBCz4+rVq8fevXvz4uVblF2NTFWpYrpNS0hQhvZtKZmS4hP399VXHTl6NILBg+syenQgmgL+x1oIIWySRmMaJdLn/GBnMQ7ueZrARUZGUrZsWbO+MmXKsH37dmJjY0lOTqZ06dLKY5nJxH+5uroSHBzM/PnzefPNN0lISKBDhw68//77FCny4L/xd+/epWjRomYfmsuUKfPQmBcsWECjRo1ITExkzpw5bNq0ifbt2yvnuHnzJtHR0TRo0EB5jtFoJC0tjaioKG7dukXNmjXNzlm2bFkiIyOV+yVLllTaN27cQK/X06JFC7PnODs7c/PmTbp06UJ6ejohISF8+eWXFC9enFGjRvHCCy8wfPhwnJ2dlZGksmXL8uabb9K+fXuzc0VFRVGjRg2zvjJlypiNApYokbVW2snJCUCZBvhft27dyjFitWzZMq5fv07jxo2VvoSEBFauXMmwYcOU13S/9U56vV4Z5cqM4+7du5QvXz7HsZGRkfdNtA4dOsSoUaPuG++0adPMRgYB3N3dSU5ONuvLvJ85mpRdly5diI6O5n//+x9xcXG0aNGCrl27kpycrPy8hg4dSpWMD9cvvvgiwcHB7Ny5k0GDBt03rkzLly/nxo0byohT/fr1GTJkCMHBwWaJv6+vL+fPn3/oufIDu0qmMr/8yRyVcnBxweEBWXNBJMUnID3dwPHjEdSv76f0ubo6snv3MLQyWieEEPmbRgOOOT/YFRRlypTJMbpx/fp1SpQoQfHixXF1dSU8PJyKFSsCphGB7MUkMiUkJHDnzh2++OILAE6fPs0bb7zBggULHjqNzNfXl5iYGJKTk5Vk6NChQ5w8eVKZ3vYgHh4eTJkyhcjISF555RVWrVqFj48Pvr6+PPPMM2zZssUsvqioKIoVK0bp0qVzVBIMDw83mxKX/UtMX19fXF1d2b9/vzIqp9PpuH79Ot7e3ly+fJlatWrRs2dPUlJS2LJlC5MnTyYwMBC9Xk/r1q15+eWXuXfvHr/88gsTJ05k3759ZtcvXbr0A/87PAmNRqOs7QE4fvw4p06dYs2aNWbT41auXMlPP/3EkCFDcHR0xM/P777TOK9evaok1aVLl6Zq1aps2rTJLGEFU1LYqlUrPvroI7p27Wr2WGBg4GNVfsxUpUoVYmNjzZKzixcv4uvrS6H7LHm5e/cuzZo1M1uH1q9fP9q3b0+xYsUoXrx4jvVMj1soIzw8PMdzHR0dlSQt+/m02vw/iS7/R2gBtlh8ArJN87PT4hM3b8bTuvWPNG++hDNnIs0ek0RKCCFEXomOjub27dtm/9LT0+nbty8rVqxg79696PV69u3bx4oVK+jTpw9arZa+ffvyzTffEBERQXJyMh999NF9P4AmJiYyfPhw1q9fj9FopGTJkmi1WmUUy9nZmXsZXwxnV7duXcqXL88nn3xCcnIykZGRfPTRR8pUssfxwQcf4Obmxttvv43RaKRVq1YkJiby/fffo9PpiI+PZ/LkyUycOBGNRkNQUBC///47u3btQq/Xs3PnTrZt2/bA89etW5dy5crx8ccfk5iYSEpKCh9++CEvv/wyer2ev/76i7Fjx3Ljxg1cXV3x8vLC0dGRQoUKERISwttvv01UVBSenp54enri7u5ulrgB9OnTh+3bt7N582b0ej2nTp3iu+++o0+fPo/9c8iudOnSZlXqli1bRosWLahatSq+vr7Kv4EDBxIZGcnmzZsB6NGjB8HBwezevRuDwYBOp+Pvv/8mJCSE3r17K+f73//+x6pVq5g3bx4xMTEYjUZOnz7NqFGjqFWrltlaoidVvnx5AgIC+PDDD0lISOD69evMnz+fvn373vf4gwcPMnjwYG7evElqaipLly7l8uXLShGOAQMG8O2333L69GnS09P56aefiIiIyDHF835at27N4cOHWbNmDUajkTNnzvDzzz/TvXt3s+Pu3LnzxFUqrcmuRqYyCqSgyyjrZ2vJVObIlD0mU7//fpFBg1Zz965pesgLL6zi8OERkkQJIYTIcxMmTMjRt2nTJjp16kRCQgKzZs0iPDwcHx8f3n77bXr27AnAm2++yQcffEDnzp3x8PCgf//+aLXaHN/I+/j4MHfuXL7++mumTp2Kq6srnTt3VkaXevbsyfTp0zl58iSffvqp8jwnJycWLFjAhx9+SMuWLXF0dKRbt268/vrrj/3aPDw8+Pzzzxk4cCA//PADr776KkuXLuXjjz/m+++/x2Aw0KhRI2WtUp06dZgxYwbTp08nJiaGwMBAnnvuuRyvKZOjoyMLFy7kk08+oX379qSmplK3bl0WL16Mi4sLQ4YM4c6dOwwYMICEhARKly7NV199ha+vL2+88QYzZ86kS5cupKamUrFiRebPn59jbc6zzz7LnDlz+Pbbb5kyZQpFixZVpgk+iaZNm3L48GH69etHdHQ0mzdv5quvvspxnLe3N61bt2bJkiV069aNnj17kpaWxueff861a9cwGAxUqFCBKVOm0CXb5qcNGzZk2bJlLFiwgC5dupCcnIy3tzcdO3Zk5MiRD/xZ5tbcuXOZOXMmbdq0QavV0rNnT7P9nPz9/ZkxYwbdu3enc+fOXLp0if79+5OUlEStWrX48ccfKV68OABjx47F09OTCRMmcOfOHSpWrMh333133wIe/9WkSRM+//xzFixYwAcffIC3tzfDhg1j4MCBZscdOXKEadOm5clrtySN0WiBuqD5iF6v5+jRowS/8y6f/276puT677+za8IEvOvVo/0DSkIWRAv9F3L76G1e2PACVbtUVTscq9DrDcycuZMPPvhbqXBbtmxhVqzoy3PPlX34k/M8FtN7rV69eg9cUCxEXpD3mrAWS73XUlJSuHz5MhUqVMDV1TXPzpvfHTx4kGrVqilTwxISEggICGDr1q33XS9TEFy+fBmDwUClSpWUvnHjxlGxYkUmTpz42OcxGo0kJSXh7u6e79Y2nzlzhpdeeomdO3fa1ftVTWFhYUycOJFt27blGHl8HA/7HaPT6Thx4kSe/V6zm2l+2QcolGl+D1nEWdAYDUZiLpvmXdvLmqmIiAQ6dFjGzJlZiVTnzlUICxtp9URKCCGEeJTFixcze/ZsUlJSSE1NZe7cuVSoUKHAJlIAFy5c4KWXXlLWKO3fv59du3blKDBRkFWvXp1mzZqxevVqtUOxG0uXLmXcuHFPlEhZm11N88tki2umos5FkRqXiqOrI97VLVteMz/YufMKAwas4vZtUwlSrVbD7NmtefvtpjK1TwghRL40ffp0ZsyYQYsWLdDr9QQEBLBo0SK1w3oq7dq148KFCwwZMoS4uDhKly7NBx98QP369dUOLU+99957DBs2jC5dujy0oqJ4eocOHSI1NfWJ17hZm30nUza0Ye+Nfaa6/qUCS+HgZNvTfr799gCvv74Fg8E0HOXn50lwcB9atCivbmBCCCHEQ/j4+DxwE9aCbPTo0YwePVrtMCyqaNGirFmzRu0w7EJgYCCBgYFqh/HY7CaZ0mZbGmaLI1PX914HoMxzD99PwhbUrJlV2rRt24osW9YLHx9PFSMSQgghhBD2yG6SqYvZhmRtMZm6uc+0j0GZxrafTLVqVYEPPmhFWpqe999vjoOD3Sz9E0IIIYQQ+YjdJFOX3LKm9GVu2utkI8lU6r1U7py8A9heMmU0Glmz5gy9elU3q+4zZUozFaMSQgghhBDCjqr5ZexzB9jeyFT4wXCMBiNFnilCoVK2sw4sJiaZXr1W0KfPSr74Yq/a4QghhBBCCGHGbpIpXWpWO83GkqnM4hO2tF7q0KFwAgIWsW7dWQCmTPmTaxmbEgshhBBCCJEf2E0y5eqe1ba1an439mYkUzYwxc9oNPLttwdo2nQxly/HAlCsmBtr1w7gGTvZP0sIIYQQQhQMdrNmqpCnqZqf0Wi0qWl+RqMxa2SqgCdT8fGpDB++npUr/1X6Gjcuw4oVfSWREkIIIYQQ+Y7djExl0qekYEhLA8DZBjZdi7kYQ1JkEg7ODvj6+6odzhM7duw2gYGLzBKpiRMbs3Pny5JICSGEyDfi4uKYPn06LVq0oF69ejz//PNMnjyZ27dvA7BgwQKaNm1KWsZnjewuX75M9erVOX36NN988w3VqlXjjTfeyHGcTqejcePGVKtW7aGxHDt2jBEjRpj1paen07x5c5o0aUJqaqrZYzdu3KBatWrcuHEjx7neeecd3nnnHbO+f/75h+HDh9O4cWMCAgLo0aMHv/7660Njyq1jx44RFBRE/fr16dq1K6GhoQ88VqfT8dlnn9G8eXMaNGjAa6+9xq1bt8zOVb16dfz9/ZV/gwYNynGeq1ev0qhRoxw/h507d9KtWzfq1atHp06d+Ouvv5THFixYwJIlS/LgFQtbYzfJlMFgus2s5KdxcMDR3f0hzygYMkel/Or74ehSMAcat2+/TOPGP3D+fDQARYq4sHp1P778sgPOzra9AbEQQogsRqORRF2i1f4Zs+1B+bgmTpxITEwMoaGhHD16lLVr16LT6Rg6dCjp6en069ePe/fusX379hzP/fXXXwkMDKRGjRqAaSPYP/74g3sZn00ybd++/b7JWHY6nY7JkyczefJks/5t27bh4+ODr68v69aty/Xry7R06VImTpxI9+7d2bFjBwcPHuS9997j22+/5dNPP33i82YXFxfHiBEj6NmzJwcOHGDq1Kl89NFHHD9+/L7Hf/HFF2zbto0ffviB3bt3U65cOYYOHYpOpwPgxIkTNGjQgLCwMOXf8uXLzc7x559/8sILLxAbG2vWf+XKFcaNG8f48eM5dOgQ48aNY8KECURERAAwbNgwVq5cycWLF/PktQvbUTA/fT8Bvd5UVjv7eqnspbYLKlsoPtGgQSmeeaYI585FUb++HyEhQVSsWPTRTxRCCGEzjEYjzy95nj3X91jtmk3LNmXX0F25+jxw+PBhZs+eTYkSpg3kvb29mTJlCl988QXx8fEUK1aMLl26sHLlSjp06KA8LyUlhTVr1jBr1iylr0qVKsTHx7Np0yb69++v9K9atYouXbqwYsWKB8YREhJCmTJlqFSpkln/smXL6Ny5Mx4eHixZsoSgoKBcf96JiIjgs88+47PPPqNz585Kf8OGDfnoo49Yv349aWlpODk5mT1vwYIFLFy48L7n3LhxI6VKlTLr27ZtG15eXgwaNAij0UjDhg3p1q0by5cvp27dujnOsWHDBiZNmkSVKlUAePPNNwkODmbv3r20aNGCEydOULt27Qe+rnnz5rF582YmTpzI+++/b/bYmjVrCAwMpG3btgB07tyZ1atXs2LFCl5//XWcnZ3p1asXc+fOZc6cOQ/56Ql7YzcjU8WLmb590sWZKsLZyh5TtlB8olAhF0JDg3j99Ybs3j1MEikhhLBTGvL/l5xdunRh2rRpTJ8+nU2bNnHz5k1KlCjBxx9/TLFixQB48cUX2bNnDzdv3lSet3HjRjw8PGjTpo3Z+Xr16sWaNWuU+xEREZw4cUL5UP8gv/zyC127djXrO3PmDKdOnaJ3795069aN6OhoduzYkevX+Pfff+Pg4EC7du1yPPb888/zySef5EikAEaNGmU2KpT9338TKYDz589TtWpVs75KlSpx5syZ+8al1+txc3NT7mcmiZcvXwZMI1P//vsv7du3p0mTJkyYMEGZfgkQFBTEhg0beO6553Kc+8KFCzliqVy5slksXbt2Zdu2bURFRd03PmGf7GZkCkzz/NIyhtJtofhEWlIat4+ZfkkUpJGp5cuP8/zzz1CunJfSV6eOD3PmdFIvKCGEEKrSaDTsGrqLpLQkq13T3ck916M2s2bNolGjRmzatImpU6dy7949nnnmGcaNG0f37t0BqFWrFvXq1SM0NJTx48cDEBwczKBBg3BwMJ++3r17dz7//HMuX75MhQoVWL16NZ07d8bFxeWBMURGRnLhwgXq169v1v/zzz/To0cPimSsCQ8KCmLx4sW0atUqV68xJiaGIkWK3DdhykuJiYlmyRGAm5sbSUn3fw+0b9+eBQsWUKNGDXx8fJg/fz6pqamkpKSg1+spWbIkTZo04YUXXiAtLY0PPviAESNGsGbNGhwcHPDx8clVLK6urmaxlCpVihIlSrB//36zETth3+wmmYrJXDNlQ5X8wg+FY9QbKVSqEIXL5P/Xk5ycxrhxm/nhhzAaNizNrl1DZU2UEEIIhUajwcPZQ+0wHkqr1dKjRw969OiB0Wjk4sWLrFu3jrfffpsSJUooox6DBw/m448/ZuzYsZw+fZoLFy4QFBSU43zFihWjZcuWrF27lokTJ7JmzRq+/vrrHOuosgsPDwcwSw5iY2PZsGEDWq2WLVu2AKZiFAkJCZw8eZLatWsrCZper89xzvT0dNwz1pKXKFGC2NhYdDodzs7OZscZDAZiY2OVUbjsFi1axKL/b+++o6K42gAO/5YONrCiWGPBhgKCqGAJRlERbNjBltgSYzcaey+JaNRYsBcw2BXF+tmiUUEUozESlVhAo6hgoS+w3x+EjRtQgSCIvM85e072zp077wyTdd+9ZVavzjBmPz+/dL1ThoaG6c4zLi6OQoUyvgcmTJjAwoUL6d27Nzo6Ori5uVGjRg2KFi2KtrY2Gzdu1Kg/ZcoUGjduTGhoaLpep38zNDQkPj5eoyw+Pj5dLKamphqLXghRYIb5mSlsgI8rmbr/y30gtVfqQ5//dfPmMxo1Wse6dcEABAY+YPfuG3kclRBCCJF5Z86cwcrKSr14gUKhoFq1aowZM4batWvz+++/q+u2bt1avY+vry+urq7qHqN/69SpE/v27SMgIIBChQpRu3btt8ahpZX69S0lbXUtYOfOnVSsWJFDhw6xb98+9u3bh7+/P/b29upV6ExMTDAwMFAnY6+7f/8+ZmZmADRt2hSVSsXx48fT1Tt58iQODg4ZJhSDBg0iKCgow1dGw/xq1KjBrVu3NMpCQ0PVc6L+7fHjxwwdOpQzZ85w8uRJ3N3d+fPPP6lbty5//fUX8+bNIyYmRl0/bWEKAwODDNt7Vyy3b99OF0tSUlK63kVRsBWYZCoxJfUXlI8pmQo7GwZAxaYV8ziSt9u27TcaNFjN1aupK+IYGemyaVNHevR48yRRIYQQ4kNja2tLiRIl+Pbbb/njjz9QKpVER0fj5+fH3bt3adGihbqujo4OPXr0YPv27Rw5coQ+ffq8sd3mzZujVCqZPXs2bm5u74wjLTFJW2kuJSWFrVu30qVLF0xNTTVePXr04PDhwzx8+BAdHR3atWvHwoUL1avSRUdHs3HjRm7evKkeulayZEmGDx/O9OnTOXDgAAkJCSiVSk6dOsXkyZPp27cvZcuWze5lVGvVqhVPnz5l48aNKJVKLl68yP79++nSpUuG9Tdu3MiECROIiYnhxYsXzJgxgzp16lCvXj1MTEzw9/dn8eLFJCQkEBkZyYwZM2jcuDEVK777e5KrqyuBgYEcPHiQpKQkDh48SGBgIB06dNCoFxERkSPnLj4eBSaZSlKljoN9fTW//CwlOUXdM1XR4cNMphISkhg27CA9euwiOjr116FatUoSGPgFffrUz+PohBBCiKwxMDBg69atlCpViqFDh2JjY0OLFi3w8/Njw4YN6VbW6969O2fOnKFu3bpUq1btje3q6Ojg6urKvXv30i0qkZHixYtTu3ZtLl26BKT2FkVERKjnbL3O0dERExMTNm3aBMC0adNo3LgxgwcPxsrKCkdHR86cOcPmzZupUKGCer9BgwYxZcoUfHx8aNasGXZ2dixZsoSRI0emW449u0xMTFi/fj2HDx+mUaNGzJo1i0mTJtGoUSMAgoKCsLKyUvekjRs3DmNjYxwdHWndujUKhYIVK1YAqX+btWvXEhoaioODA05OThQuXJgffvghU7FUrVqV5cuX4+Xlha2tLStWrGDZsmVUqVJFXScsLIznz59nuICFKLgUquw8ZCEfSU5O5sqVK/x45C4bJnbh/MSJ3Nm3D8tRo6j9xRd5HV62Pb76mFX1V6FXWI/xUePR0vmw8uI7d6Lo2nUHly79MwzA3b0eK1c6U7iw3lv2zL/S7jVLS0sZAiDeK7nXRG55X/dafHy8esGFzAzBEul5e3tz6tQp1q5dm9eh5AiVSkVsbCxGRllfFCS3eHl5ERISwuLFi/M6FPEOb/uMSUxM5Nq1azn2ufZhfQN/j+L+nlP4sQzzu3fmHpA6X+pDS6SePInB2nq1OpHS19dmzRoXNm/u+NEmUkIIIURu6tatG/fu3eP27dt5HUqBkJiYyM6dOxk+fHhehyI+MB/Wt/D36JMqqR1waUuj5/fnTH3I86VKlSrEF19YAVCtWnEuXPiCL76w/mB/aRJCCCHyGz09PRYsWMCCBQvyOpQCYe3atXTv3l1j2J8QUICWRk/zMfRMqVQqdc/Uhzpfau7clhQqpMfo0Y0pWvTNz8oQQgghRPZYW1uzZs2avA6jQPjyyy/zOgTxgSowPVO6itTxkh9DMhUfFc+rB6k9bGYNzfI4Gjh06BZbtvyqUaarq8306S0kkRJCCCGEEB+tAtMzVUovdYWaj2E1v5iI1Gco6BfTR69Q3s1BSkpKYerUk8ybdxZ9fW0sLMpgaWmaZ/EIIYQQQgiRmwpMzxQKBSlKJUmxsQDoveHBeflBzJPUZKpQqbx7SvzDh69o2XIz8+adBSAhIZn164PzLB4hhBBCCCFyW4HpmQJI/HvxCQDdwoXzMJL/JvZJakJoVMooT45//Pif9Oq1m4i/e8i0tRUsWPAZo0fLcxeEEEIIIUTBUWCSKS2tf5IpnUKF0NLJv6eeVz1TyckpzJlzhunTT5H2dLLy5YuybZsbTZpUePvOQgghhBBCfGTyb0aRRRUqKEh88QLI34tPQN70TEVExNC7927+978/1WVt2lRjy5ZOlCyZNz1kQgghhBBC5KWCM2eKj2MlP/inZyq3kimVSkWHDr7qREpLS8GcOY74+/eSREoIIUSBYm5uzqBBg1ClDdH42+7du3F0dMxUG35+fjg7O+d4bMuWLaNWrVpYWVlhZWVF/fr1ad26NT4+Pjl+rJwQFhZGjx49UCqVGuVubm5YWFjw5MmTdPuYm5sTEBCQrnzZsmV4eHholF29epXhw4fTpEkTrK2tadu2LV5eXiQlJeXYOdy5c4e+fftiZWWFg4MDq1atemNdlUrFmjVrcHR0xNramn79+nHz5s0M6y5evDjd/XT+/Hm6du2KtbU19vb2zJo1i/j4+HT7RkRE0KRJE3bv3q0u279/P7Nnz87mWYq3KVDJVNoDe/N7MpXWM5Vbw/wUCgWLFzuho6OFqWlhjh/vw8SJTdHSkofwCiGEKHhOnz7N2rVrs72/q6sr/v7+ORjRP2xsbAgODiY4OJgrV64wffp05s2bx4ULF97L8f6LCRMmMGzYMHR1ddVlv/76K48ePaJZs2Z4e3tnu+3Dhw/Tp08fbG1tOXr0KJcuXcLT05P9+/czZsyYnAgfpVLJkCFDsLCwICAggNWrV+Pj48OhQ4cyrL9lyxbWrl3LwoULCQwMpGXLlvTp04fIyEiNeufPn2fdunUaZZGRkQwePJiePXsSFBTEnj17CAwMZPXq1Rr1UlJSGDt2LFFRURrlLi4u/P7775w/fz4Hzly8rsAkU1raH0/PVF4M82vUqDzbtrlx5cpgWrSonGvHFUIIUYCoVBATk3uvf/UuZZaHhwdLlizh8uXLb6xz4sQJevToQePGjalfvz7u7u7cvXsX0OzF6t27N4sWLdLYt2vXrupk7fr163h4eGBra0vr1q3ZuHFjul6xN1EoFDRp0oQaNWrw22+/Aam9I6tXr8bFxQUbGxtsbW0ZM2YM8fHxPH78mNq1a2uc19OnT6lTpw73799HpVKxefNmnJycsLGxoVevXup2AY4cOYKzszMNGjSgbdu2rFix4o2xnTp1isjISBwcHDTKfXx8aNOmDb169cLX15e4uLhMnevrEhISmDZtGl999RUeHh4ULlwYhUJB7dq1WbhwISqViufPn6fbz8/PT92r9+9XUFBQuvoXL14kIiKC4cOHo6enR+3atfHw8HhjT+CBAwfw8PDA2toaHR0dPDw8MDEx4fDhw+o6T58+ZfLkyel62YoXL865c+fo3LkzCoWC58+fk5CQQPHixTXqLV++HFNTU8qWLZvu+O7u7nh6embmEoosKDDJVPnyH08y9b4XoLhwIZx+/faSnJyiUd65cy3KlMm/qyAKIYT4gKlU4OAAhQvn3qtp02wlVK1ataJ79+6MHj06wy/ljx49YsSIEQwaNIjz589z6tQpVCoVy5cvT1e3a9eu+Pn5kZKS+m9uaGgoN27coGPHjjx+/Ji+ffvSpk0bzp07x4oVK9i6dSvbtm3L5CVVERgYSHh4OM2bNwfg0KFDbN68mWXLlhEUFISvry9nz55l//79lClTBnt7e/bt26duIy3BqFixIlu3bmXDhg0sWbKE8+fP07lzZ/r378/Tp0+Jj49n3LhxTJ06Vd0LtGbNGq5evZphbFu3bqV9+/YaZZGRkRw5coSePXvSpEkTSpQowa5duzJ1rq+7fPkyz58/T9c+QM2aNVm6dCnGxsbptrm6uqp79f79srGxSVf/1q1bVKlSBT29f575Wa1aNUJCQjKMKzk5GSMjzR/CtbS0+PPP1GkUab1KAwcOpHr16un2L/z3StTNmzfHxcWFUqVK0blzZ/X2Cxcu4O/vz7Rp0zI8vqOjI6GhoVy7di3D7SJ7CkwypVD8k0zp5uMH9gLEPv27ZyqH5yupVCoWLz5P06Yb2LTpV2bN+jlH2xdCCCHeSpF/ho+PHz+e4sWLM2HChHQ9RcWLF8ff3x9HR0eio6N59OgRJiYmPH78OF07bdq0ISYmRj0PaPfu3TRv3pySJUvi5+dH1apV6d27N7q6ulSrVo3PP//8rXOgLl26hI2NDTY2NlhYWODh4UHz5s2pVKkSAM2aNWPnzp1UrlyZyMhIoqKiMDY2VsfWpUsXDh8+TGJiIgB79uyhS5cuQGqv0eDBg6lZsya6urq4ublRtWpV/Pz8ADAwMGDnzp2cP3+eqlWrcunSJerVq5cuxpSUFAIDA7G2ttYo3717Nw0bNqRq1aooFAo8PDzYuHGjOtHMrLRhcyVLlszSflkVExODoaGhRpmhoSGxfz/T9N+cnJzYsmULN27cQKlU8tNPP3Hnzh0SEhIAWLlyJUWKFKFHjx5vPe7Ro0f5+eef0dLSYvjw4QA8e/aMiRMnsnDhQgoVyvjHdgMDA2rWrClD/XJYgVnNDz6OnqnHVx8T8/jvnqnSOdcz9fx5PAMG7GPPnn9+TTl58i6TJ6ego1Ngcm4hhBB5RaGAM2fgDV9E3wsjo2wncHp6evzwww906tSJ9evXY2Jiot6mq6vLgQMH8PX1RaFQUKNGDaKjo9HJ4LEsBgYGuLi4sHfvXho2bIifnx+zZs0C4MGDB1y/fl2jVyQlJQVtbe03xtWgQQO2bNmifn/z5k3Gjh3L2LFjWbp06d8/nC7m5MmTFC9enFq1aqFUKtUJoaOjI9OmTeP06dOUK1eOBw8e4OTkpI5nwYIFLFy4UN1+UlISdevWxcDAgJ9++okVK1YwZswYoqOjcXJyYvLkyRQrVkwjxufPnxMXF0fp0qU12tm5cyevXr3Czs5Ofa4vX77k2LFj6hj09PRITk5Od95JSUnqHqJSpUoB8OTJE8qVK5eu7pMnT9R1Xrd//35mzJiR4XVdtWpVut4pIyOjdMMQ4+Li3pjMDBgwgLi4OL766isSExNp27YtDg4OFC1alIsXL7J7926NRSPexMDAAAMDA8aNG0fXrl158eIF33zzDR4eHtStW/et+5qamvLo0aN3HkNkniRT+UjUn1F4O3mTkpRCpeaVKFohZ87j0qWHdO26gzt3nqvLvvmmCbNnO0oiJYQQIvcoFPCGL6IfoooVKzJr1iy++eYbjeFWhw4dwtvbm59++kndIzRr1qw3rtzWrVs3evbsSatWrVAoFDRt2hRI/eJrZ2ensRhBVFQUMTExmY6xRo0adO3aVT1XZuHChTx8+JATJ06oh425uLio6+vp6eHi4oK/vz/lypWjbdu26qFppqamDB8+XGMlwvv372NsbEx0dDQRERHq49y4cYPRo0ezatUqxo8frxGT4u8E9vUevf/9738kJiZy4MABjaRzyZIlbNiwQZ1MlS1blgcPHqQ7z/v372NmZgaApaUlxsbGHDx4kC+++EKjXkhICB06dMDX1xcrKyuNbS4uLhrX4l2qV6/O3bt3SUpKUsd8+/btDIfoATx+/Bg3NzdGjBgBpCaAjo6OdOrUCT8/PyIjI2nZsiWQurhFQkICNjY2rFq1Ci0tLSZOnIifn586aUxMTERXV5eYmBgCAwP59ddf1UNJo6OjmTFjBkeOHMHLy0sdQ3JyMlpa8t0uJxWoq5mfV/OLfhTNllZbiH4UTWmL0nTf0139YZRdKpWKlSsv0qTJenUiZWJiwP79PVmwoBW6um/+5UsIIYQQ0K5dO7p06aIxj+nVq1doaWlhYGCASqXi559/Zu/evemWAE9Ts2ZNPvnkE+bOnUunTp3UPU8uLi5cuXIFPz8/kpKSiIiIYMiQIcyfPz/T8T169Ag/Pz8aNGgApH7J1tfXR1tbm4SEBNavX8/Nmzc1YnNzc+PMmTMcO3ZMI0ns1q0bK1euJDQ0FIAzZ87g7OzMxYsXiYmJYeDAgezfvx+VSkXp0qXR0tLS6LFLY2JigpGRkcawR29vb9q2bYuZmRmmpqbql4eHB8HBwepFMVxdXfHy8lLPxYqPj2f//v2cOHGCjh07AqkJ4eTJk/nxxx/x8fEhJiaG5ORkgoKCGDFiBE5OTukSqeyws7PDxMQET09PEhISCAkJYcuWLbi5uWVY39/fny+//FKdEHt6eqKnp4ejoyOzZs0iODiYoKAggoKCmDZtGuXKlSMoKAgbGxvMzc2Jj4/H09OTxMREdS+hm5sb5cqV49q1a+p9g4KCKFeuHNOmTdNIpCB12fSMeutE9knPVD4Q/zwebydvov6MwriKMe5H3DE0MXz3jm/x6lUCgwYdwNf3n1V4GjY0Y/t2NypVMv6PEQshhBAFx8SJE/n11195+ff3jE6dOnHp0iWcnZ3R1tbmk08+oW/fvvj4+KjnIv1bt27dmDZtmsYXcTMzM/VS2rNnz0ZbW5sWLVowadKkN8YSFBSkkSgYGhrSvHlzde/QyJEj+fbbb2nSpAlGRkY0aNCADh06aPSa1axZk4oVKxIbG6tOwgD69euHSqXiyy+/JCIigjJlyjB16lR1b8rSpUv54YcfmDp1KgYGBrRr145+/fplGKe9vT2XLl3C3t6ekJAQgoKCMlyyvHbt2tStW5f169djbW3N0KFD0dPTY8KECTx69AiFQoG5uTnLli3TmIPl4uKCiYkJ69evZ9myZSQkJFC2bFm6dOlC//7933j9skJHR4f169czc+ZM7O3tMTIywsPDQ52APnz4EGdnZ9asWYONjQ39+/fnr7/+ol27diiVSmxsbNi4cSP6+vrvPFahQoVYu3Ytc+fOxd7eniJFiuDi4sJXX32V6XgTEhK4fv26ehipyBkKVWbX18ynkpOTuXLlCsYVTbju8SXRYWG08vamVA78IpEblLFKvJ28uX/2PoXKFGLALwMoXrX4u3d8hylTTjB79hn1+5Ej7ViwoBV6etIblV1p95qlpeVbx7ML8V/JvSZyy/u61+Lj47lz5w5VqlTBwMAgx9oVOWfYsGHUq1ePQYMGvZf2T548yffff8/BgweB1NEysbGxGBkZ/eeRNyJjBw4cYPPmzWzfvj2vQ3nv3vYZk5iYyLVr13Lsc63ADPMzK2L2T89UPlnNL1mZzI5uO7h/9j76xfRxP+KeI4kUwMSJTalXrwxFi+qzc2dXFi9uI4mUEEIIUcCFhYVx7Ngx9TON3pdPP/2UYsWKcfr06fd2DKFp8+bNjB49Oq/D+OgUmGF+qpSUf+ZM/WtVmQ+RKkWF3wA/bvnfQsdAh14HemFa3zT77alUGr/0GBrqsmtXNxQKqJpDCZoQQggh8rcff/yR48ePM3HixPe+tPj8+fMZN24cTZo0yXClQ5Fz9u3bR506dWjUqFFeh/LRKTB3blJsLKq/n1Pwoc+ZUqlUHB51mKveV1FoK+i6sysVHSpmu70bN57w+ed+bNzYkRo1SqjLq1WTJEoIIYQQ/1iwYEGuHatSpUrqIWcf+ayTPNehQwc6dOiQ12F8lArMML+0XiktPT20MzHRLy+dmXOGwKWBAHTc2JEazjWy3ZaPz1Vsbddw/nw4XbvuIC4u45WEhBBCCCGEEFlT4JKpD71X6uLKi5ycchKANkvaUM89/ZPDMyM+PonBg/fj7r6HmJjUBCo5OYUnT3LxYYhCCCGEEEJ8xArMML/E6A8/mbq+/ToHv0pd1abZlGbYDbfLVju3b0fStesOrlz55wnX/ftb8uOP7TAy0s2RWIUQQgghhCjoCkwypYyOBj7cZCr0aCi73XeDCmyG2tBiRotstbNz5+8MGLCPV69Sn2NhaKjD8uXt6N8/fywFL4QQQgghRH5RcJKpD/iBveEXwtnWaRspyhTqdK9D22Vts/yMhcTEZMaNO8rSv+daAZibl2DHjq5YWJTJ6ZCFEEIIIYQo8ApMMpX4gc6ZirgewVbnrShjlVRtXZVOmzuhpZ31qWwXLz5g2bJ/EqmePevi5dWeIkU+7MU2hBBCCCGEyK8KzgIUH+Awv+d3n+Pd2pu4yDjM7Mzotqsb2tl8cK69fUWmTm2Onp42q1Y54+PTWRIpIYQQQggh3qOCk0z93TOlW6RIHkeSKiYihi2tt/Dq4StK1S5FL/9e6BXWy/T+SmVyumcyTJnSjCtXBjN4sE2WhwkKIYQQ4t0cHR2xsLDAysoKKysrLC0t6dChAzt27MiR9v38/HB2ds6xelk1depU9blZWFhQs2ZN9XsrKyuCgoJy/JgZCQsLo0ePHiiVmo90cXNzw8LCgidPnqTbx9zcnICAgHTly5Ytw8PDQ6Ps6tWrDB8+nCZNmmBtbU3btm3x8vIiKSkpx87hzp079O3bFysrKxwcHFi1atUb6zo7O2tcZysrK8zNzfHy8uLhw4fpttWrVw9zc3OCg4M12omMjKRVq1Ya1+H1v2naq1atWnz++ecA7N+/n9mzZ+fYeRc0BSeZevnhDPNLeJmAdxtvIm9FUqxSMdyPumNUwijT+4eHv6RFi00sWaL5gaGtrUWtWqVyOlwhhBBCvGbGjBkEBwcTHBxMYGAgX331FfPnz2f16tX/uW1XV1f8/f1zrF5WzZw5U31uM2bMoFy5cur3wcHB2NjY5PgxMzJhwgSGDRuGru4/qxD/+uuvPHr0iGbNmuHt7Z3ttg8fPkyfPn2wtbXl6NGjXLp0CU9PT/bv38+YMWNyInyUSiVDhgzBwsKCgIAAVq9ejY+PD4cOHcqwvr+/v8Z17tu3L7Vq1cLd3T3d3+DixYtYWVnh5uaGldU/C4xdunSJ7t27c//+fY22X/+bBgcHs2zZMooWLcqECRMAcHFx4ffff+f8+fM5cu4FTYFJptRzpooVy9M4kuKT+Mn1Jx4FP8KolBEeRz0oapb5BO/w4dtYWq7i3Lkwxo07xvnzYe8xWiGEECL3qFQqEmMSc+317xEe2aGnp0fr1q0ZP348P/74I9F/Tyt4+vQpY8eOxd7eHgcHB6ZOnareBvDLL7+ovww7Ojqqk4Pdu3fj6OgIQFJSEtOnT8fe3h47Ozt69erFpUuX0tUDCAoKonfv3tjY2ODo6MgPP/xAYmLqyr7Lli1j+PDhjB07FhsbG5o1a4anp2e2zjc8PBxzc3Pmz5+Pra0tM2bMAFKTARcXFxo0aEDnzp05e/asep/ExESWLFlCy5YtadiwIQMHDuTevXtvPMapU6eIjIzEwcFBo9zb25s2bdrQq1cvfH19iYuLy3L8CQkJTJs2ja+++goPDw8KFy6MQqGgdu3aLFy4EJVKxfPnz9Pt5+fnl6535229dRcvXiQiIoLhw4ejp6dH7dq18fDwwMfH550xXrhwgU2bNvHDDz9QqFChdNtXrlzJs2fPmDZtmrpsz549jB07llGjRr217cjISMaOHcukSZOoXr26utzd3T3b90RBV2AWoEhKmzOVh8P8UpJS2NljJ/dO30OviB7uh90pUaNEpvZNSkph+vRTzJlzRl1mZlYEHZ0Ckw8LIYT4iKlUKjY4bCDsXO79SFjBvgL9z/TPkaHxLVq0YMqUKVy+fBkHBwe+/PJLKleuzJEjR1AqlXz77bdMnTqVRYsWcefOHYYMGcK0adPo2LEjISEh9OnTh0qVKmm0uW/fPoKDgzl06BCFChVi6dKlzJgxAz8/P416f/75J/3792fs2LFs2LCBv/76i6+//pro6GgmT54MwNGjR5k/fz4LFizg7NmzDB48mJYtW2JpaZmt842JieGXX34hPj6e06dPM23aNFauXIm1tTU///wzX3/9Ndu3b6d69eosXryYCxcusHHjRkqXLs2aNWsYMGAABw8eRF8//fzurVu30r59e42yZ8+eceTIEfbs2cMnn3xCiRIl2LVrF+7u7lmK+/Llyzx//jxd+wA1a9Zk6dKlGe7n6uqKq6trpo9z69YtqlSpgp7eP1M4qlWr9s7ey+TkZKZNm8bQoUOpXLlyuu33799n9erVbNmyRaNtBwcHXFxc0NHReWtCtXDhQurWrZvuXBwdHZk0aRLXrl3DwsIik2cpoCD1TOXxQ3tVKhX7B+7nj31/oK2vTU+/npS1Lpupff/66xWtWm3RSKTat6/B5cuDsbU1e18hCyGEELkrH0/3NTExAeD58+f89ttvXL9+nWnTplG4cGFMTEwYP348/v7+REVF4e/vT506dXBzc0NHR4e6deuydetW6tSpo9GmgYEB4eHh7Ny5kzt37jBixIh0iRSkznkxNzenb9++6OnpUalSJcaMGcOOHTtISUkBoHLlynTs2BFtbW2aN29OqVKluHv3brbPt2PHjujp6VG0aFG8vb3p2bMntra2aGtr8+mnn+Lo6Iivry8qlQpfX19Gjx5NhQoV0NfX56uvvkKpVHLq1Kl07aakpBAYGIi1tbVG+bZt22jYsCFVq1ZFoVDg4eHBxo0b1eeXWZGRkQCULFky2+eeGTExMRgaGmqUGRoaEhsb+9b99u/fT2xsLH369Mlw+6pVq2jevHm6JLhUqVLo6Ly9jyQsLAw/P78MhzIaGBhQs2ZNGeqXDQWmZyovnzOlUqk4Nu4YVzZeQaGlwG2bG5VbVM7UvidO3KFXr108fhwDgLa2gnnzWjJmTBO0tPLxvzpCCCHEaxQKBf3P9EcZq3x35Ryia6SbYws2pX1JL1GiBOHh4SQnJ9O8eXONOnp6eoSFhREREUG5cuU0ttWsWTNdm87OziiVSnbs2MGiRYsoUaIEQ4YMoWfPnhr1nj17RoUKFTTKypcvT3x8PM+ePQNSv2y/TldXN8uJyOtKly6t/u8HDx4QGBjITz/9pC5LTk6mUaNGREZGEhsby4gRI9DS+uc3fKVSyYMHD9K1+/z5c+Li4jTaT0pKwtfXl5cvX2JnZwekJl0vX77k2LFjODk5AanXNzk5OV2bSUlJ6l6ctOvw5MmTdH+DtPJ/XytITXLShjT+26pVq9LNJTMyMko3DDEuLi7DYXuv2759O927d8fAwCDdtpiYGPz9/VmzZs1b23iTXbt2qRefyIipqSmPHj3KVtsFWcFJpvJwafRfvvuF856pmb7LWhdqdkj/gflvKSkq5sz5menTT5OSkjqm28ysCL6+bjg4VHyv8QohhBB5QaFQoFco8yvbfkhOnDiBkZER9evX5+bNmxgYGBAQEIC2duojTxITEwkLC6NSpUqULVuW06dPa+y/a9cuSpTQHPp/584d6tSpQ8eOHYmPj+fw4cOMHz8+3Rd3MzMzjh49qlF2//599PT0KPae5oq/noSamprSsWNHBg0apC57+PAhBgYGGBsbo6+vz/r16zV6U/7880/KlCnzxnZfn8927NgxEhMT8ff3V19PgCVLlrBhwwZ1MlW2bNkME7T79+9jZpY6ksfS0hJjY2MOHjzIF198oVEvJCSEDh064Ovrq7GwA6Qu0uDi4vLO65KmevXq3L17l6SkJHWP0e3btzXmKf3b06dPuXz5MgsWLMhw++nTpylevDi2traZjuN1R48eZcCAAW/cnpycrJHwiswpMFcs5e9JmLmdTF1ee5njE44D0GphK6z6W71jj1QxMYls3nxVnUi1bl2V4ODBkkgJIYQQH5DExEQOHjzIokWLGDVqFIULF6ZevXpUqlSJ+fPnExMTQ3x8PHPnzqVfv34kJyfj7OzM77//zt69e0lOTua3335j/vz56YZpnTx5kmHDhhEeHq5OTHR0dCjyr/nfzs7OhIaGsmnTJhITE7l//z6LFi3CxcVFY17N+9KtWzc2b97M1atXAbh27RqdO3fmwIEDaGlp4ebmhqenJ48ePSIlJYU9e/bQvn37DBehMDExwcjIiMePH6vLvL29cXFxwczMDFNTU/XLw8OD4OBgLl++DKTOa/Ly8lLHER8fz/79+zlx4gQdO3YEUnuvJk+ezI8//oiPjw8xMTEkJycTFBTEiBEjcHJySpdIZYednR0mJiZ4enqSkJBASEgIW7Zswc3N7Y37XL58mdKlS6frZXx9e4MGDbLVmxoVFUVoaOhbE7GMekzFuxWYnikAhZYWOu/oXs1JN3bf4MDgAwDYT7CnyZgmmd63SBF9duzoir39er791oGJE5vKsD4hhBDiAzBt2jRmzZoFgL6+Pp988gkzZsygXbt2AOjo6ODl5cWCBQto3bo1CQkJ1KtXjw0bNqCvr0/FihVZvXo1np6ezJo1ixIlSjBhwgQcHBzYvXu3+jh9+vTh8ePH9OjRg+joaMzMzFi8eDGmpqYa8ZQvX561a9eyaNEili1bhoGBAe3bt2fkyJG5cj3atGlDbGwsEydO5OHDhxgbG9OvXz/1s53Gjx/PsmXL6NWrF8+fP6dChQosXbqU2rVrZ9ievb09ly5dwt7enpCQEIKCgtQLabyudu3a1K1bl/Xr12Ntbc3QoUPR09NjwoQJPHr0CIVCgbm5OcuWLdOYg+Xi4oKJiQnr169n2bJlJCQkULZsWbp06UL//v1z5Jro6Oiwfv16Zs6cib29PUZGRnh4eNC5c2cgtefO2dmZNWvWqHsaw8LCMuytSxMWFka1atWyFU94eDjAG9tPSEjg+vXr6vtaZJ5ClRPrgn7AkpOTuXLlCrcGDUJHXx+3c+dy5bh3TtzBp60PyYnJWH1hhctql7f+kpCSouLlywSMjTXHyEZExFC6dO4lgCL70u41S0tLjWEIQuQ0uddEbnlf91p8fDx37tyhSpUqGc4NEQWPSqUiNjYWIyMjTp06xffff8/BgwfzOqwC48CBA2zevJnt27fndSg54m2fMYmJiVy7di3HPtcKzDA/yL0hfg+DHuLbwZfkxGRqda5F+1Xt35pIRUbG0aGDL87OW1EqNSdOSiIlhBBCiILk008/pVixYunmlYn3Z/PmzYwePTqvw8iXJJnKYU9DnuLT1ofE6ESqtKxC562d0dJ+82UOCAjHysqLAwducu5cGN9+e/y9xyiEEEII8SGbP38+y5cvR6nMvdUdC6p9+/ZRp04dGjVqlNeh5EsFas7U+06mXoS9YEvrLcQ+jaWcTTm67+mOjn7Gl1ilUrFsWSBjxx5FqUxdmrRECUM+++yT9xqjEEIIIcSHrlKlSh/NkLMPXYcOHejQoUNeh5FvSTKVQ2KfxuLd2puXYS8pYV6CXgd7oV8k/VO9AV68iOfzz/3YteuGuqxJkwr4+nahQoX3s4SpEEIIIYQQImdJMpUDEl4l4NPOh6chTylavigeRz0oVCrjuU7BwX/RtesOQkOj1GXjxjVhzhxHdHVlIrkQQgghhBD5RYFKpnT/9VyGnJCUkMS2Ttt4ePEhhiUMcT/qTrGKGfcueXkFMWLEYRISUheZMDY2YNOmjri6mud4XEIIIYQQQoj3q0AlUzndM5WSnMLu3ru5c/wOuoV06X2oN6VqlXpj/ZCQp+pEyta2HNu3d6VyZeMcjUkIIYQQQgiROwpWMlUs5+YjqVQq/If6c2PXDbT1tOmxtwdmtmZv3WfBglacPx9Ow4ZmfP99K/TfsDiFEEIIIYQQ4sNXoL7N6+XgML8Tk05wec1lFFoKOm/tzCcZrMIXGhpJ1arF/zm+njanTvXDwKBAXXYhhBBCCCE+SvKcqWw4v+g8Z+edBcB5lTO1u9TW2B4bq2TAgH1YWKzk2rXHGtskkRJCCCFEfnD37t28DkGID54kU1l0ZdMVjo45CkDLeS1pMLCBxvY//niKnd1aNmy4QlxcEm5uO4iPT/rPxxVCCCFE3jM3NycgIECjbNeuXVhYWLB169YM9wkICMDc3JzVq1en2zZhwgQmTJjwXmL9L06cOMHnn3/+xu0eHh40b96cqKgojfLw8HDMzc0JDw9/5zEePnyIlZUVDx8+fGfdtGv4JsuWLcPDw+Od7bxPs2bN4sCBAxplp06dwtzcnNmzZ6er/7aY/32fJSYm4uXlhYuLCw0aNKBJkyYMHTqU69ev5+g5rFmzhmbNmmFpaYmHhwd//vnnG+tev36d3r17Y2Njg4ODA7NnzyYxMRGAqVOnYmVlpfGqVauWxj3Vtm1b6tevr1EnNDQUgKdPn2Jubq6xzdHREQClUkmPHj0ydY/lhgKVTOn+x2TqD78/8PvcD4DGYxpjP95eY/tPP13DxmYNv/0WAYCRkS5TpjST3ighhBAiE1QqFUmxsbn2UqlU/znm1atXM3v2bJYuXUqvXr3eWnfJkiVcvnz5Px8zNzx//vyd1+fRo0eMHz8+29exXLlyBAcHU65cuWzt/yE5f/48v//+O+3bt9co9/b2pmfPnuzatYsXL15kq+2EhATc3d05c+YMCxYs4OLFixw7dox69erh7u7O1atXc+IU2LNnD1u2bGHdunUEBARQp04dhg8fnuHfNyUlhcGDB+Pk5ERgYCA7d+7k7NmzrFmzBoCZM2cSHBysfi1btoyiRYuqfziIjo7mzp07HDx4UKNe1apVAbh27RpmZmYa206cOAGArq4uw4cPZ/z48Tly3v9VgfqW/196pu6evsuObjtQJauw7GdJq+9boVAoAIiPT2LUqMOsWnVJXb9OnVLs2NGVWm9Z3U8IIYQQqVQqFcfc3Xl65UquHbOUlRWfbdmi/vc8K1QqFXPmzOHQoUNs3rwZCwuLd+7Ts2dPRo8ezZ49ezAxMcmwzrlz51i0aBF3796lTJkyDB48GFdXVyD1C+j8+fMJDAwkIiKCIkWK0Lt3b4YMGQKAo6MjDg4OHD9+nFKlSrF7925u3LjB/PnzCQkJwcTEhF69etG3b18UCgWPHz9m0qRJXL16FQMDA+rVq8fUqVO5c+cO06ZNQ6lUYmVlxeHDhylTpky6WDt27Mjx48dZu3YtAwcOzPB8oqOjWbRoEcePHycxMZFGjRoxadIkSpYsSXh4OC1btuT48eOYmZnx8OFD5s+fT3BwMKVLl6ZHjx7MmzePP/74Q93eunXr8PX15cmTJzRr1oy5c+dSuHBhAGJjY5kwYQInT56kePHiDB48mI4dOwIQHx/P0qVL8ff3JzY2lpo1azJu3Djq1asHpPYEeXh4sH//fqysrFi4cCFTpkzh3Llz6OjoULNmTSZOnKj+sv9vnp6eDBgwQKPs3r17XLhwgVOnThESEsK2bdsYNGjQm26PN9qyZQvh4eEcPXpUfa6FChVi6NChvHz5kps3b6rP43XOzs4Z9vo1aNCAtWvXpivfvn07vXr1onr16gCMGTOG7du3ExAQQKNGjTTqvnjxgidPnpCSkqJOtrS0tDA0NEzXbmRkJGPHjmXSpEnqtn/77TeMjY0xM8t48bZr165Rt27dN16TJk2aMGvWLE6fPk3z5s3fWC83FKieqewuQPFX8F/4uvqSnJCMuas5Lmtc1B+8oaGRNGmyTiOR6tOnPgEBX0giJYQQQmRBdpKavKBUKhkzZgw7duzA19c3U4kUwDfffEPx4sWZMGFChr/2h4SEMHToUAYNGkRAQACzZs1i7ty5nDlzBoCFCxcSHh7Ozp07CQ4OZvLkySxevJh79+6p27h69ao6wXvy5Al9+/alTZs2nDt3jhUrVrB161a2bdsGwKJFizA1NeWXX37h4MGDxMbGsnr1auzs7JgxY4a65yijRAqgfPnyzJkzhx9++OGNPW4TJ07k3r177N69m//9738ULlyYYcOGpTv/5ORkhg8fTunSpTl79izr1q1j79696dp78OABBw4c4MiRI1y5cgUfHx/1tt9++426dety9uxZJk+ezOTJkwkKCgJg+vTpnD17ls2bN/PLL7/w2Wef0a9fP41k4/79+5w6dYrvvvuO9evXEx0dzenTpzl58iSlSpVi4cKFGZ7j1atXCQ0NVQ9DS+Pt7U3r1q0pWbIkHh4ebNmyRT0MLitOnDhBixYt1InU68aPH4+bm1uG+/n7+2v07KS9MkqkAG7fvk2NGjXU73V1dalcuTIhISHp6pqYmNCvXz8WLFiAhYUFzZs3p3LlyvTr1y9d3YULF1K3bl31jwKQmiwZGhri7u6OnZ0dnTt35uTJkxrbHz16RPv27WnUqBEDBw7k9u3bGu06Ozu/cWhtbiowPVPaRkZo6WT9dJ/deoZPGx8SXiZQqXkluvh2QUsnNQf1979Jr167efkyAUhdXGL58nb072+Zb/5BEEIIIT4ECoWCz7ZsITkuLteOqW1omK1/r6dMmULZsmXR19dn9+7djBgxIlP76enp8cMPP9CpUyfWrVvHF198obHd19eXli1b0rp1awCsra3p1q0bPj4+NG3alK+//hptbW0KFy7Mo0eP0NfXByAiIoJKlSoB4OTkRNG/R+Js27aNqlWr0rt3bwCqVavG559/jre3Nz169EBfX5+LFy/i7+9P48aNWbt2LVpaWfud3cnJie7duzN69Oh0yc+zZ884cuQIhw4dokSJEkBqcmVjY8P169cxNjZW1/3111+5f/8+O3fuxMjICCMjI0aNGpWuJ+frr79GX1+fMmXKYGtry/3799XbatWqhbu7OwD29vY4OTmxb98+LCwsOHDgAMuXL1dfp759+7J//34OHDigPkb79u0xNDTE0NAQAwMDQkJC2Lt3L/b29sydO/eN1+bChQvUqlULAwMDdVlsbCx79uxh3bp16uv03Xff4e/vT6dOnbJ0jSMjI7G1tc3SPtkRExOTrmfJwMCA2NjYdHVTUlIwMDBgypQpuLm5ce/ePYYNG8bSpUsZOXKkul5YWBh+fn7s2LFDY3+FQoGFhQWjR4+mXLlyHD58mK+//hpvb28sLS0pWrQo1apVY+DAgejp6bFkyRL69+/PwYMHKfJ354i1tTVr165FpVLl6ffuApNMZadX6uWDl2xptYWYiBhMrUzpsa8Huoa66u3GxgbExKT+wlC9enF27uxGvXoZ/3ojhBBCiLdTKBToGBnldRjvVL9+fb777jvOnTvH0KFDqVWrljoB8vPzY9q0aeq6M2bM0OjZqVixIrNnz2bcuHE0aKC5iNWDBw+4cOECNjY26rLk5GQqVqwIpCYnc+bM4ffff6d8+fLqYVApKSnq+qVLl9Zo7/r16xrtpaSkoK2tDcDkyZPx8vJi3bp1TJgwgZo1azJ58mSN+pkxYcIErly5woQJE5g0aZLG8QG6deumUV9bW5vw8HCNZOqvv/7C2NgYo9f+/uXLl093rNeHR+rq6pKcnPzG+mXLluXmzZu8ePECpVKZbnv58uU1FjF4/dqlfYnfuXMnM2fOpEKFCowZM0b9d37dX3/9la73bu/evbx69UojGYyJiWH9+vXqZEpfX5+kpPSLlKWVpSXLpUqVIiIiIl09SB1uZ2hoiJ6eXrptLi4u/PXXX+nKGzRogJeXV7pyQ0ND4uPjNcri4+MpVKhQurrHjh3jyJEjHD58GIDq1avz1VdfMWfOHI1kateuXerFJ1737x8SXF1d1T2OlpaWeHp6amz/9ttv2bVrF0FBQXz66acAlClThri4OKKioihevDh5pcAkU7pZTKbiIuPwdvLmxb0XFK9eHPfD7hgUM9CoY29fkXnzWnL58iNWr25PkSL6ORmyEEIIIT5APXv2RE9PjxYtWjBo0CDGjx9PpUqVMDc3x9XVVWM4E5Bu9b+2bdsSEBDA6NGjMTc3VycVpqamdOrUiZkzZ6rrRkREqIfEjRgxAkdHR9atW4eOjg5RUVFs375do+3Xf6E3NTXFzs5O3TsCEBUVRUxMDAC///473bt35+uvvyYyMpLly5czbNgwLly4kKXroaenx+LFi+ncuTMbNmxQl6clGIcOHaJUqX+mPty+fZsKFSrw5MkTdVm5cuWIiooiLi5OnVBlZpW/1/074QgLC8PMzIySJUuir69PWFiYxpyn+/fvawzNe/3a/fHHHzg6OtKvXz9evXrF1q1bGTVqFBcuXFD3jKTR0tLSSGgBtm7dyogRI+jcubO6LCoqii5dunD27FkcHBwwNTXN8BzThm2WLVsWSJ0Lt3btWqKjo9MN9Zs0aRJxcXEaf+M0+/fvz/hCvUH16tW5deuWOllRKpXcvXtXY+hfmr/++ivdkEUdHR10dXU1yo4ePZpuLhmkzn2rXbs2jRs3VpclJiair69PdHQ0y5cvx93dXT2nKjk5maSkJI3ev7REOu3HgbxSYOZMZWUlv8SYRLY6b+XJ9ScUKVcEj6MeFCpdiHPnwkhJ0RzjO3ZsE7Zu7SyJlBBCCFEAjRgxAktLS7766iueP3+e6f0mTpxIsWLFNOaJuLm5ceDAAc6ePUtKSgp3797F3d2d9evXA/Dq1SsMDAzQ1tYmMjJSvdy2UqnM8BguLi5cuXIFPz8/kpKSiIiIYMiQIcyfPx+AVatWMWvWLKKjoylatCiGhobqnh99fX3i4uIy7DnJSKVKlZg1a5bGHKYyZcrQokUL5syZQ1RUFEqlkpUrV+Lm5sbLly819q9fvz6ffPIJCxYsIC4ujsePH7N06dJMXs1UV69eZdeuXSiVSk6ePMmJEyfo2rUrWlpadOnShUWLFnHv3j0SExPZtGkTt2/fxtnZOcO2duzYwTfffMOzZ88oXLgwhQsXxsjIKMMeoHLlyvH48T/PFT1//jx3796le/fumJqaql+1atWiWbNm6r9ns2bNSEhIYPHixURHR6NSqbh//z7z5s3DwcFBnYz26tWLkiVLMnToUEJCQlCpVERFReHp6ckvv/zC8OHDs3Sd3qRLly54e3sTEhJCQkICnp6elCxZMsOeSgcHB548ecKqVatITk4mLCyMlStX4uLioq4TFRVFaGhohkMU//rrL2bMmEFYWBhJSUnqeYCdOnWicOHCnDt3jgULFvDq1StiYmKYNWsW5cuX14glIiICIyMjihUrliPnn10FJpnSy2DSXkaSE5PZ3mU74RfCMTAxwP2oO4XLF2XChP9hb7+eefPOaNRXKBQyP0oIIYQooLS0tPD09CQpKYmRI0dqDDt7m7T5U68Poapfvz6LFi1i0aJF2Nra4u7ujqOjI2PGjAFg3rx5HDx4EGtrazp37kyZMmWoXbs2N2/ezPAYZmZmrF27lm3bttGkSRM6dOjAJ598ok6mZs6cSUpKCi1btsTW1pZff/2VJUuWAGBra0uJEiWwtbXVWE3vbdq1a0f37t01yr777juKFi1Kx44dadSoEadPn2bt2rUaPVVp1/H777/n7t27NG7cmL59+2Jra5uup+NtmjRpwvHjx2nYsCGLFi1iyZIl1K5dG0hd/MPBwYF+/fphZ2fHoUOHWLduHVWqVMmwrdGjR1OpUiWcnZ2xtrZm9+7drFixQj307nX29vZcv36dhITUOfQ+Pj40a9ZMPU/sdT169OCXX34hJCQEY2NjNm/ezM2bN/nss8+wsrKiT58+VK5cWf13gNTE1sfHh7p16zJ8+HAaNGiAs7MzoaGheHt7U79+/Uxfo7dxc3OjX79+fPXVVzRq1Ijff/8dLy8v9d9g6tSp6uF51apVw8vLixMnTmBnZ0efPn1wdHRk1KhR6vbShlBmtIDJN998Q7NmzejVqxc2Njb4+vqyevVq9Zy2FStWkJKSwmeffUbTpk158uQJa9as0bgfLl26RNOmTXPk3P8LhSonHrLwAUtOTubKlSsk7NtHk9e6zTOSkpzC7t67ub7tOrpGunj8zwOtisXo2XMXZ86kTnDU0lJw6dIgLC1NcyN8kY+k3WuWlpZ53uUsPm5yr4nc8r7utfj4eO7cuUOVKlU0hu2IgisuLo4LFy7QtGlTdP5eMOzEiRNMmzZNvZrhh6xz58588cUXtGvXLq9DKTDatm3Lt99+S7NmzdJte9tnTGJiIteuXcuxz7WC0zP1jjlTKpWKQ8MPcX3bdbR0tei2uxsh0YlYWXmpEykdHS08PVtTv74sMiGEEEIIkVN0dXUZP348O3bsICUlhWfPnrF+/Xr1/J0P3ZgxY9i0aVNeh1FgnD59mhIlSmSYSOW2ApNMvWsBilPTTxG0IggU4LqxI1vOheHk5M2TJ6nLQVaoUJQzZ/ozcmQjGdYnhBBCCJGDtLW1WbRoEXv27MHW1hYXFxeqV6/OhAkT8jq0TLG3t6dWrVr4+fnldSgfPaVSyY8//si8efPyOhRAVvMDIGBZAD/P/BkAu3ktGb0umBMn7qi3t2tXnc2bO1KixIe/XKsQQgghRH5kZWXFtm3b8u2P1tOnT8/rEAoEXV3ddM+tyksFJpl60zC/qz5XOTw8dY38il/Z0P+HAB49igZAW1vB7NmOfPONPVpa+fN/bCGEEEIIIcT7UXCG+WWwmt+tg7fY128fAA2HN6TbglaUKJH65OeyZQtz4kRfJkxwkERKCCGEeA8+8jWwhBB5JDc/WwpOMvWv50zd/+U+2922k5KUgkVvC9osbkOhQnrs2NGVDh3MuXJlCM2aVcqjaIUQQoiPV9ryxrGxsXkciRDiY5T22ZKVpfWzq0AO83t89TE/tf+JP+OSqNuiEh02dEDxd+9TrVql2Lu3R16FKYQQQnz0tLW1MTY2JiIiAgAjI6N8O09G5AyVSkVCQgJaWlpyL4hsU6lUxMbGEhERgbGxca48PqTAJFNpw/yi/oxiS+stHH8ez3GgXlQ8Q5NVaL//xFUIIYQQfzM1TX1eY1pCJQo2lUqFUqlEV1dXkinxnxkbG6s/Y963gpNMFSlC9KNovBw3sfFxDGnP8r7y62OWLw9kzJgmeRqfEEIIUZAoFArKli1L6dKlUSqVeR2OyGPJycmEhIRQrVo1eRi5+E90dXVz9R4qMMlUUgLMbboBr3sveP5a+bffOjBiRKO8CksIIYQo0LS1teXLsyA5ORkAAwMDuR9EvpInC1A8e/aML7/8EhsbG+zs7JgzZw5JSUkZ1j19+jQuLi5YWlrStm1bTp48ma1jjvh0M9/fjlQnUsWLG3LwYC/mzm2Jjk6BWYdDCCGEEEIIkUPyJIsYOXIkRkZGnDlzhp07d3L+/Hk2btyYrt7du3f5+uuvGTFiBEFBQXz99deMHDmSx48fZ/mYO+6+IOXv/27cuDxXrgymbdvq/+1EhBBCCCGEEAVWridT9+7dIzAwkHHjxmFoaEiFChX48ssv8fHxSVd3z5492NjY8Nlnn6Gjo0O7du2wtbVl27Zt2T7+mDGNOX26HxUqFPsvpyGEEEIIIYQo4HJ9ztStW7cwNjamTJky6rKqVavy8OFDXr58SdHXngd1+/ZtatSoobF/tWrVCAkJyfTx0h7aVaqEPlu2dMTZuToqVTKJicn/8UyE0JQ23jsxMVHGe4v3Su41kVvkXhO5Re41kVsSExOBnHuwb64nUzExMRgaGmqUpb2PjY3VSKYyqmtgYJClh/ylpKQO7tu5+1MgnmvXrmUzciEy5/fff8/rEEQBIfeayC1yr4ncIveayC1pOcJ/levJlJGREXFxcRplae8LFSqkUW5oaEh8fLxGWXx8fLp6b6Ojo4OFhYU8BE4IIYQQQogCTqVSkZKSgo5OzqRBuZ5MVa9enefPn/P06VNKliwJQGhoKKamphQpUkSjbo0aNbh+/bpG2e3bt6lbt26mj6elpYWent5/D1wIIYQQQgghXpPrC1BUrlyZBg0aMHfuXKKjowkLC2PFihW4ubmlq+vq6kpgYCAHDx4kKSmJgwcPEhgYSIcOHXI7bCGEEEIIIYTQoFDl1OyrLHj69CkzZ84kICAALS0tOnbsyNixY9HW1sbKyooZM2bg6uoKwJkzZ1i4cCH379/HzMyMcePG0bx589wOWQghhBBCCCE05EkyJYQQQgghhBD5XZ48tFcIIYQQQggh8jtJpoQQQgghhBAiGySZEkIIIYQQQohskGRKCCGEEEIIIbLho0imnj17xpdffomNjQ12dnbMmTOHpKSkDOuePn0aFxcXLC0tadu2LSdPnszlaEV+lpV77aeffsLJyQkrKyucnJzw8fHJ5WhFfpaVey3NzZs3qV+/PgEBAbkUpfgYZOVeCwwMpGvXrlhZWdG8eXO8vLxyOVqRn2XlXtu0aROOjo5YW1vj4uLCkSNHcjla8TGIjIykVatWb/138T/nBqqPgLu7u2rMmDGq2NhY1f3791XOzs6qNWvWpKt3584dlYWFherYsWMqpVKp8vf3V9WrV0/16NGjPIha5EeZvdeOHTumsrGxUQUHB6tSUlJUly9fVtnY2KgOHz6cB1GL/Ciz91qa2NhYVfv27VU1atRQXbhwIRcjFfldZu+127dvq+rXr6/avXu3KiUlRXXjxg1Vw4YNVYcOHcqDqEV+lNl77dSpU6rGjRurQkNDVSqVSnX48GFVzZo1VWFhYbkdssjHgoKCVJ999tlb/13Midwg3/dM3bt3j8DAQMaNG4ehoSEVKlTgyy+/zLAXYM+ePdjY2PDZZ5+ho6NDu3btsLW1Zdu2bXkQuchvsnKvPX78mIEDB2JpaYlCocDKygo7OzsuXryYB5GL/CYr91qaGTNm8Nlnn+VilOJjkJV7bevWrbRs2ZJOnTqhUCioWbMmvr6+NGjQIA8iF/lNVu61P//8E5VKpX5pa2ujq6uLjo5OHkQu8qM9e/YwduxYRo0a9c56/zU3yPfJ1K1btzA2NqZMmTLqsqpVq/Lw4UNevnypUff27dvUqFFDo6xatWqEhITkSqwif8vKvda7d28GDRqkfv/s2TMuXrxI3bp1cy1ekX9l5V4D2Lt3L/fu3WPYsGG5Gab4CGTlXrt69Srly5dn9OjR2NnZ0bZtWwIDAylVqlRuhy3yoazca87OzpQsWZJ27dpRp04dRowYwfz58zE1Nc3tsEU+5eDgwLFjx2jXrt1b6+VEbpDvk6mYmBgMDQ01ytLex8bGvrOugYFBunpCZCQr99rrnjx5wsCBA6lbty7t27d/rzGKj0NW7rXQ0FAWL16Mp6cn2trauRaj+Dhk5V578eIFmzdvxtXVlV9++YWZM2eyYMECDh8+nGvxivwrK/eaUqmkZs2a7NixgytXrjBz5kwmTZrEH3/8kWvxivytVKlSmerJzIncIN8nU0ZGRsTFxWmUpb0vVKiQRrmhoSHx8fEaZfHx8enqCZGRrNxraa5cuYKbmxtVqlRh5cqVMkRBZEpm77WEhARGjRrFxIkTKVeuXK7GKD4OWflc09PTo2XLlrRo0QIdHR1sbW3p0KEDhw4dyrV4Rf6VlXtt1qxZVK9enXr16qGnp0eXLl2wtLRkz549uRavKBhyIjfI98lU9erVef78OU+fPlWXhYaGYmpqSpEiRTTq1qhRg1u3bmmU3b59m+rVq+dKrCJ/y8q9BrBz50769etH37598fT0RE9PLzfDFflYZu+1a9eucffuXSZNmoSNjQ02NjYADBkyhOnTp+d22CIfysrnWtWqVUlMTNQoS05ORqVS5UqsIn/Lyr328OHDdPeajo4Ourq6uRKrKDhyIjfI98lU5cqVadCgAXPnziU6OpqwsDBWrFiBm5tburqurq4EBgZy8OBBkpKSOHjwIIGBgXTo0CEPIhf5TVbutSNHjjB9+nSWLVvGgAED8iBakZ9l9l6zsbHh6tWrBAUFqV8Aq1atkmRKZEpWPtd69OjB8ePH2bdvHyqViosXL7J//375N1RkSlbuNUdHR7y9vbl+/TopKSkcPnyYgICAd85/ESKrciQ3yIGVB/PckydPVF9//bWqYcOGqkaNGqnmz5+vSkpKUqlUKpWlpaVq37596ro///yzytXVVWVpaalydnZWnTp1Kq/CFvlQZu+19u3bq2rWrKmytLTUeE2ZMiUvwxf5SFY+114nS6OLrMrKvXbq1ClV586dVVZWVqqWLVuqfvrpp7wKW+RDmb3XlEqlaunSpapPP/1UZW1trerUqZPq559/zsvQRT72738Xczo3UKhU0j8vhBBCCCGEEFmV74f5CSGEEEIIIURekGRKCCGEEEIIIbJBkikhhBBCCCGEyAZJpoQQQgghhBAiGySZEkIIIYQQQohskGRKCCGEEEIIIbJBkikhhBBCCCGEyAZJpoQQQhRor169IjIyMq/DyLS7d+/mdQhCCCH+JsmUEEIUYI6OjlhYWGBlZaXxGjBgQKb2Nzc3JyAgIEdjCg8Px9zcHEtLS3U8lpaWODk5sXfv3v/cvp+fH87Ozur3rVq14tatWxluyym7d++mZs2aGte4fv36fPrpp3h6eqJSqTLVjo+PD1OmTMnx+IQQQmSPTl4HIIQQIm/NmDGDzp0753UY6Rw4cIDy5csDoFKpOHjwIGPHjqVMmTI0btw42+26urri6uqqfh8VFfXGbTmpXLlynDhxQv0+OTmZ06dPM3z4cCpWrEjXrl3f2UZ+6kETQoiCQHqmhBBCvNHjx48ZOXIkjo6O1K9fn5YtW7Jz584M6x45cgRnZ2caNGhA27ZtWbFihXrb06dPGTt2LPb29jg4ODB16lSio6MzHYdCocDZ2ZmiRYty48YNAB48eMDIkSNp3Lgx9vb2jBkzhoiICACSkpKYPn069vb22NnZ0atXLy5dugSk9hI5OjoC4OTkBMDAgQNZs2aNxrbevXuzaNEijTi6du3K2rVrAbh+/ToeHh7Y2trSunVrNm7cmOkeJgBtbW0cHR2pUaOG+pwSExNZsGABbdu2xcrKisaNGzNr1ixUKhV79uzBy8uLoKAgbGxsAIiOjmbmzJk0b96cxo0bM2rUKJ4+fZrpGIQQQvw3kkwJIYR4o8mTJ6Orq4u/vz+XL1/G3d2dWbNmERMTo1EvPj6ecePGMXXqVC5duoSnpydr1qzh6tWrpKSk8OWXX6KlpcWRI0fYv38/ERERTJ06NdNxxMXFsXXrVqKjo2nUqBFKpZIBAwagra3N0aNHOXToEABDhgwhKSmJffv2ERwczKFDhzh37hy2trbMmDEjXbtHjhwBYM2aNQwcOFBjW9euXfHz8yMlJQWA0NBQbty4QceOHXn8+DF9+/alTZs2nDt3jhUrVrB161a2bduW6XNKTEzk0KFD/PHHHzRv3hyATZs2cebMGTZt2kRwcDArVqzA19eXCxcu0KlTJwYPHoyNjQ1BQUEATJw4kXv37rF7927+97//UbhwYYYNG5alpE4IIUT2yTA/IYQo4GbMmMHcuXM1yn7++WeMjIyYPXs2hQoVQldXl4cPH1KoUCHi4+N58eIFhQoV0tjHwMCAnTt3kpKSgrW1NZcuXUJLS4urV69y/fp1NmzYoN5n/PjxtGnThilTpmBiYpJhXK6urmhppf7mp62tTZUqVVi8eDG1a9fm/PnzhIWFsWvXLgoXLqw+j4YNG/Lbb79hYGBAeHg4O3fupFmzZowYMYJRo0Zl6bq0adOGOXPmEBAQQOPGjdm9ezfNmzenZMmSrFmzhqpVq9K7d28AqlWrxueff463tzc9evTIsL2HDx9iY2ODSqUiMTERlUpFkyZNWLZsmTqZ6tatG506daJEiRJEREQQHx9PoUKFePz4cbr2nj17xpEjRzh06BAlSpQAUpMrGxsbrl+/Tt26dbN0vkIIIbJOkikhhCjgpk2b9sY5U2FhYXz33XfcvXuXypUrU6lSJQB1b00aAwMDfvrpJ1asWMGYMWOIjo7GycmJyZMnEx4eTnJysjphSKOnp0dYWNgbkyk/Pz/1nKl/e/bsGSYmJupECqBw4cIYGxvz4MEDnJ2dUSqV7Nixg0WLFlGiRAmGDBlCz549M31dDAwMcHFxYe/evTRs2BA/Pz9mzZoFpA4xvH79unq4Xdo10dbWfmN7r8+ZCg0NZeTIkejp6dG0aVN1nbi4OGbOnMnFixcxNTWldu3aqFSqdNc7LQZITcBep62tTXh4uCRTQgiRCySZEkIIkSGlUsngwYMZPXo0vXr1QqFQ8Ntvv+Hn55eubnR0NBEREXh6egJw48YNRo8ezapVq2jVqhUGBgYEBASok43ExETCwsLUyVlWmZmZERUVRXR0tDqhevXqFVFRUZQqVYo7d+5Qp04dOnbsSHx8PIcPH2b8+PEayU9mdOvWjZ49e9KqVSsUCoU68TE1NcXOzo5169ap60ZFRaUb/vgmVatWZc2aNXTq1IlJkybx3XffAanDKosVK8bZs2fR19cnJSUFW1vbDNsoU6YMAIcOHaJUqVLq8tu3b1OhQoUsnacQQojskTlTQgghMqRUKomPj8fAwACFQsHDhw/5/vvv1dteFxMTw8CBA9m/fz8qlYrSpUujpaWFiYkJ9erVo1KlSsyfP5+YmBji4+OZO3cu/fr1Izk5OVuxWVhYUK1aNaZNm8arV6949eoV06dPp2LFilhbW3Py5EmGDRtGeHg4BgYGGBsbo6OjQ5EiRdK1paenx6tXrzI8Ts2aNfnkk0+YO3cunTp1UieDLi4uXLlyBT8/P5KSkoiIiGDIkCHMnz8/0+dgamrK/Pnz2bdvH3v27AFSk1J9fX20tLSIjo7mu+++Izo6Wn299fX1iY6ORqVSUaZMGVq0aMGcOXOIiopCqVSycuVK3NzcePnyZVYvqRBCiGyQZEoIIUSGjIyMmDt3LsuXL8fKyoo+ffpgb29PyZIluXnzpkbdMmXKsHTpUtasWYO1tTXt27enUaNG9OvXDx0dHby8vHj69CmtW7fGwcGB+/fvs2HDBvT19bMVW1qbSUlJODk58emnn6JUKtmwYQM6Ojr06dOHFi1a0KNHDywtLfn+++9ZvHgxpqam6drq3r07Y8aMYfHixRkeq1u3bjx8+BA3Nzd1mZmZGWvXrmXbtm00adKEDh068Mknn2QpmQJo3ry5elGPsLAwJk+eTEhICA0bNqRNmzZER0fTtGlT9fX+9NNPef78OQ0aNODly5d89913FC1alI4dO9KoUSNOnz7N2rVrNXqqhBBCvD8KlSz5I4QQQgghhBBZJj1TQgghhBBCCJENkkwJIYQQQgghRDZIMiWEEEIIIYQQ2SDJlBBCCCGEEEJkgyRTQgghhBBCCJENkkwJIYQQQgghRDZIMiWEEEIIIYQQ2SDJlBBCCCGEEEJkgyRTQgghhBBCCJENkkwJIYQQQgghRDZIMiWEEEIIIYQQ2fB/mi+DMWu7UN8AAAAASUVORK5CYII="
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 19
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "language": "python",
   "display_name": "Python 3 (ipykernel)"
  }
 },
 "nbformat": 5,
 "nbformat_minor": 9
}
